@isikk/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,79 @@
+declare const getKeys: <T extends object>(obj: T) => Array<keyof T>;
+type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};
+type RecursiveRecord = {
+    [key: string]: string | number | boolean | RecursiveRecord | Array<RecursiveRecord>;
+};
+declare function forcedType<T>(obj: unknown): T;
+
+declare function notNone<T>(value: T | null | undefined): value is T;
+declare function allCombinations<T>(options: T[]): T[][];
+
+declare function withAttributes<Fn extends (...args: never[]) => unknown, Attrs extends Record<string, unknown>>(fn: Fn, attributes: Attrs): Fn & Attrs;
+declare function makeCallable<T, R>(originalCallable: (arg: T) => R): (data: T) => () => R;
+declare function getLazyValue<T>(input: T | (() => T)): T;
+declare function getLazyValueAsync<T>(input: T | (() => Promise<T>) | (() => T)): Promise<T>;
+declare function suppress<T, ERT>(exceptions: Array<new (message?: string) => Error>, fn: () => T, onError?: (error: unknown) => ERT): T | ERT | undefined;
+declare function preventDefault<E extends Event, R>(callable: (event: E) => R): (event: E) => Promise<Awaited<R>>;
+declare function isPathMatched(pathname: string, pattern: RegExp, exemptPatterns?: RegExp[]): boolean;
+declare function raises(error: Error): (...args: unknown[]) => never;
+declare function cloned<Fn extends (...args: never[]) => unknown>(fn: Fn): Fn;
+declare function enabledIf<R>(condition: boolean | (() => boolean), options: {
+    ifNotEnabledReturnValue: R;
+}): <Fn extends (...args: never[]) => R>(fn: Fn) => Fn;
+declare function transformExceptions<E extends Error>(exceptionTypes: Array<new (...args: never[]) => E>, transform: (error: E) => Error, options?: {
+    keepOriginal?: boolean;
+}): <Fn extends (...args: never[]) => unknown>(fn: Fn) => Fn;
+
+declare function checkRequiredKeys<T extends Record<string, unknown>, C extends Record<string, Array<keyof T>>>(obj: T, conditions: C): keyof C;
+declare function requireExclusiveKeys<T extends Record<string, unknown>, C extends Record<string, Array<keyof T>>>(conditions: C, options?: {
+    allowEmpty?: boolean;
+}): <Fn extends (arg: T) => unknown>(fn: Fn) => Fn;
+declare function setKeyValueToObjectIfValue(key: string, value: unknown, object: Record<string, unknown>): void;
+
+declare function slugify(value: string, allowUnicode?: boolean): string;
+
+declare const LONG_DATE_FORMAT = "EEEE, MMMM dd, yyyy 'at' hh:mm a";
+declare const SHORT_DATE_FORMAT = "dd.MM.yyyy";
+declare const SHORT_DATETIME_FORMAT = "dd.MM.yyyy HH:mm a";
+declare function formattedDate(pattern: string, date?: Date): string;
+declare function longFormattedDate(date?: Date): string;
+declare function shortFormattedDate(date?: Date): string;
+declare function shortFormattedDateTime(date?: Date): string;
+declare function optionalDate(date?: string): Date | undefined;
+
+type MimeType = 'image/png' | 'image/jpeg' | 'image/webp';
+declare function guessImageMimeType(filename: string): MimeType;
+declare function isImageMimeType(mimeType: string): mimeType is MimeType;
+declare function escapeName(name: string): string;
+declare function safeFileName(filename: string, maxLength?: number): string;
+declare function downloadAndFormatImage(src: string, name?: string, mimeType?: MimeType, quality?: number): Promise<void>;
+declare function fileToBase64Native(file: File): Promise<string>;
+declare function fileToBase64(file: File, quality?: number): Promise<string>;
+
+declare function getCookie(name: string): string | undefined;
+
+type WindowLike = Window & typeof globalThis;
+declare function createConsoleDebugSwitch(targetWindow: WindowLike, options: {
+    namespace: string;
+}): void;
+
+type TailwindShade = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+type TailwindColorScale = Record<TailwindShade, string>;
+/**
+ * Generates a Tailwind-style 50-950 color scale from a single base hex color, treated as the 500 shade.
+ */
+declare function generateTailwindColorScale(baseColor: string): TailwindColorScale;
+/**
+ * Like {@link generateTailwindColorScale}, but prefixes each shade with `name` (e.g. `primary500`)
+ * so multiple scales can be spread into one flat palette object.
+ */
+declare function generateNamedTailwindColorScale<T extends string>(baseColor: string, name: T): Record<`${T}${TailwindShade}`, string>;
+/**
+ * Formats a hex color as the "H S% L%" triplet shadcn/Tailwind CSS variable themes expect,
+ * e.g. for `--primary: 240 5.9% 10%;` consumed as `hsl(var(--primary))`.
+ */
+declare function hexToHslTriplet(hex: string, precision?: number): string;
+
+export { LONG_DATE_FORMAT, type RecursivePartial, type RecursiveRecord, SHORT_DATETIME_FORMAT, SHORT_DATE_FORMAT, type TailwindColorScale, type TailwindShade, allCombinations, checkRequiredKeys, cloned, createConsoleDebugSwitch, downloadAndFormatImage, enabledIf, escapeName, fileToBase64, fileToBase64Native, forcedType, formattedDate, generateNamedTailwindColorScale, generateTailwindColorScale, getCookie, getKeys, getLazyValue, getLazyValueAsync, guessImageMimeType, hexToHslTriplet, isImageMimeType, isPathMatched, longFormattedDate, makeCallable, notNone, optionalDate, preventDefault, raises, requireExclusiveKeys, safeFileName, setKeyValueToObjectIfValue, shortFormattedDate, shortFormattedDateTime, slugify, suppress, transformExceptions, withAttributes };

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+declare const getKeys: <T extends object>(obj: T) => Array<keyof T>;
+type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};
+type RecursiveRecord = {
+    [key: string]: string | number | boolean | RecursiveRecord | Array<RecursiveRecord>;
+};
+declare function forcedType<T>(obj: unknown): T;
+
+declare function notNone<T>(value: T | null | undefined): value is T;
+declare function allCombinations<T>(options: T[]): T[][];
+
+declare function withAttributes<Fn extends (...args: never[]) => unknown, Attrs extends Record<string, unknown>>(fn: Fn, attributes: Attrs): Fn & Attrs;
+declare function makeCallable<T, R>(originalCallable: (arg: T) => R): (data: T) => () => R;
+declare function getLazyValue<T>(input: T | (() => T)): T;
+declare function getLazyValueAsync<T>(input: T | (() => Promise<T>) | (() => T)): Promise<T>;
+declare function suppress<T, ERT>(exceptions: Array<new (message?: string) => Error>, fn: () => T, onError?: (error: unknown) => ERT): T | ERT | undefined;
+declare function preventDefault<E extends Event, R>(callable: (event: E) => R): (event: E) => Promise<Awaited<R>>;
+declare function isPathMatched(pathname: string, pattern: RegExp, exemptPatterns?: RegExp[]): boolean;
+declare function raises(error: Error): (...args: unknown[]) => never;
+declare function cloned<Fn extends (...args: never[]) => unknown>(fn: Fn): Fn;
+declare function enabledIf<R>(condition: boolean | (() => boolean), options: {
+    ifNotEnabledReturnValue: R;
+}): <Fn extends (...args: never[]) => R>(fn: Fn) => Fn;
+declare function transformExceptions<E extends Error>(exceptionTypes: Array<new (...args: never[]) => E>, transform: (error: E) => Error, options?: {
+    keepOriginal?: boolean;
+}): <Fn extends (...args: never[]) => unknown>(fn: Fn) => Fn;
+
+declare function checkRequiredKeys<T extends Record<string, unknown>, C extends Record<string, Array<keyof T>>>(obj: T, conditions: C): keyof C;
+declare function requireExclusiveKeys<T extends Record<string, unknown>, C extends Record<string, Array<keyof T>>>(conditions: C, options?: {
+    allowEmpty?: boolean;
+}): <Fn extends (arg: T) => unknown>(fn: Fn) => Fn;
+declare function setKeyValueToObjectIfValue(key: string, value: unknown, object: Record<string, unknown>): void;
+
+declare function slugify(value: string, allowUnicode?: boolean): string;
+
+declare const LONG_DATE_FORMAT = "EEEE, MMMM dd, yyyy 'at' hh:mm a";
+declare const SHORT_DATE_FORMAT = "dd.MM.yyyy";
+declare const SHORT_DATETIME_FORMAT = "dd.MM.yyyy HH:mm a";
+declare function formattedDate(pattern: string, date?: Date): string;
+declare function longFormattedDate(date?: Date): string;
+declare function shortFormattedDate(date?: Date): string;
+declare function shortFormattedDateTime(date?: Date): string;
+declare function optionalDate(date?: string): Date | undefined;
+
+type MimeType = 'image/png' | 'image/jpeg' | 'image/webp';
+declare function guessImageMimeType(filename: string): MimeType;
+declare function isImageMimeType(mimeType: string): mimeType is MimeType;
+declare function escapeName(name: string): string;
+declare function safeFileName(filename: string, maxLength?: number): string;
+declare function downloadAndFormatImage(src: string, name?: string, mimeType?: MimeType, quality?: number): Promise<void>;
+declare function fileToBase64Native(file: File): Promise<string>;
+declare function fileToBase64(file: File, quality?: number): Promise<string>;
+
+declare function getCookie(name: string): string | undefined;
+
+type WindowLike = Window & typeof globalThis;
+declare function createConsoleDebugSwitch(targetWindow: WindowLike, options: {
+    namespace: string;
+}): void;
+
+type TailwindShade = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+type TailwindColorScale = Record<TailwindShade, string>;
+/**
+ * Generates a Tailwind-style 50-950 color scale from a single base hex color, treated as the 500 shade.
+ */
+declare function generateTailwindColorScale(baseColor: string): TailwindColorScale;
+/**
+ * Like {@link generateTailwindColorScale}, but prefixes each shade with `name` (e.g. `primary500`)
+ * so multiple scales can be spread into one flat palette object.
+ */
+declare function generateNamedTailwindColorScale<T extends string>(baseColor: string, name: T): Record<`${T}${TailwindShade}`, string>;
+/**
+ * Formats a hex color as the "H S% L%" triplet shadcn/Tailwind CSS variable themes expect,
+ * e.g. for `--primary: 240 5.9% 10%;` consumed as `hsl(var(--primary))`.
+ */
+declare function hexToHslTriplet(hex: string, precision?: number): string;
+
+export { LONG_DATE_FORMAT, type RecursivePartial, type RecursiveRecord, SHORT_DATETIME_FORMAT, SHORT_DATE_FORMAT, type TailwindColorScale, type TailwindShade, allCombinations, checkRequiredKeys, cloned, createConsoleDebugSwitch, downloadAndFormatImage, enabledIf, escapeName, fileToBase64, fileToBase64Native, forcedType, formattedDate, generateNamedTailwindColorScale, generateTailwindColorScale, getCookie, getKeys, getLazyValue, getLazyValueAsync, guessImageMimeType, hexToHslTriplet, isImageMimeType, isPathMatched, longFormattedDate, makeCallable, notNone, optionalDate, preventDefault, raises, requireExclusiveKeys, safeFileName, setKeyValueToObjectIfValue, shortFormattedDate, shortFormattedDateTime, slugify, suppress, transformExceptions, withAttributes };

package/dist/index.js

@@ -0,0 +1,490 @@
+// src/types/index.ts
+var getKeys = Object.keys;
+function forcedType(obj) {
+  return obj;
+}
+
+// src/arrays/index.ts
+function notNone(value) {
+  return value !== null && value !== void 0;
+}
+function combinationsOfSize(items, size) {
+  if (size === 0) {
+    return [[]];
+  }
+  if (size > items.length) {
+    return [];
+  }
+  const [first, ...rest] = items;
+  const withFirst = combinationsOfSize(rest, size - 1).map((combination) => [first, ...combination]);
+  const withoutFirst = combinationsOfSize(rest, size);
+  return [...withFirst, ...withoutFirst];
+}
+function allCombinations(options) {
+  const result = [];
+  for (let size = 1; size <= options.length; size++) {
+    result.push(...combinationsOfSize(options, size));
+  }
+  return result;
+}
+
+// src/functions/index.ts
+function withAttributes(fn, attributes) {
+  for (const key of Object.keys(attributes)) {
+    Object.defineProperty(fn, key, {
+      value: attributes[key],
+      writable: true,
+      configurable: true,
+      enumerable: true
+    });
+  }
+  return fn;
+}
+function makeCallable(originalCallable) {
+  return (data) => () => originalCallable(data);
+}
+function getLazyValue(input) {
+  if (typeof input === "function") {
+    return input();
+  }
+  return input;
+}
+async function getLazyValueAsync(input) {
+  if (typeof input === "function") {
+    const result = input();
+    if (result instanceof Promise) {
+      return await result;
+    }
+    return result;
+  }
+  return input;
+}
+function suppress(exceptions, fn, onError) {
+  try {
+    return fn();
+  } catch (error) {
+    if (exceptions.some((exception) => error instanceof exception)) {
+      return onError ? onError(error) : void 0;
+    }
+    throw error;
+  }
+}
+function preventDefault(callable) {
+  return async function(event) {
+    event.preventDefault();
+    return await callable(event);
+  };
+}
+function isPathMatched(pathname, pattern, exemptPatterns = []) {
+  if (exemptPatterns.some((exempt) => exempt.test(pathname))) {
+    return false;
+  }
+  return pattern.test(pathname);
+}
+function raises(error) {
+  return () => {
+    throw error;
+  };
+}
+function cloned(fn) {
+  return ((...args) => fn(...args));
+}
+function enabledIf(condition, options) {
+  const enabled = typeof condition === "function" ? condition() : condition;
+  return function(fn) {
+    if (!enabled) {
+      return cloned((() => options.ifNotEnabledReturnValue));
+    }
+    return cloned(fn);
+  };
+}
+function transformExceptions(exceptionTypes, transform, options = {}) {
+  const { keepOriginal = true } = options;
+  return function(fn) {
+    return ((...args) => {
+      try {
+        return fn(...args);
+      } catch (error) {
+        if (!exceptionTypes.some((ExceptionType) => error instanceof ExceptionType)) {
+          throw error;
+        }
+        const newError = transform(error);
+        if (keepOriginal) {
+          newError.cause = error;
+        }
+        throw newError;
+      }
+    });
+  };
+}
+
+// src/objects/index.ts
+function checkRequiredKeys(obj, conditions) {
+  const matchingConditions = Object.entries(conditions).filter(
+    ([, keys]) => keys.every((key) => obj[key] !== void 0) && Object.keys(obj).every((key) => keys.includes(key) || obj[key] === void 0)
+  );
+  if (matchingConditions.length !== 1) {
+    throw new Error(`Object keys do not match exactly one required condition. ${JSON.stringify(conditions)}`);
+  }
+  return matchingConditions[0][0];
+}
+function requireExclusiveKeys(conditions, options = {}) {
+  const conditionEntries = Object.entries(conditions);
+  if (conditionEntries.length === 0) {
+    throw new Error("At least one condition must be provided.");
+  }
+  const { allowEmpty = false } = options;
+  const governedKeys = new Set(conditionEntries.flatMap(([, keys]) => keys));
+  return function(fn) {
+    return ((arg) => {
+      const provided = new Set(
+        Object.keys(arg).filter((key) => governedKeys.has(key) && arg[key] !== void 0)
+      );
+      if (allowEmpty && provided.size === 0) {
+        return fn(arg);
+      }
+      const matches = conditionEntries.filter(
+        ([, keys]) => keys.length === provided.size && keys.every((key) => provided.has(key))
+      );
+      if (matches.length !== 1) {
+        throw new Error(`Object keys do not match exactly one required condition. ${JSON.stringify(conditions)}`);
+      }
+      return fn(arg);
+    });
+  };
+}
+function setKeyValueToObjectIfValue(key, value, object) {
+  if (value) {
+    Object.defineProperty(object, key, { value, writable: true, configurable: true, enumerable: true });
+  }
+}
+
+// src/strings/index.ts
+function slugify(value, allowUnicode = false) {
+  if (allowUnicode) {
+    value = value.normalize("NFKC").replace(/[^\p{L}\p{N}_\s-]/gu, "");
+  } else {
+    value = value.normalize("NFKD").replace(/[^\x00-\x7F]/g, "").replace(/[\r\n]+/g, " ").trim().replace(/[^\w\s-]/g, "");
+  }
+  value = value.toLowerCase();
+  return value.replace(/[-\s]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
+}
+
+// src/dates/_format.ts
+import { format } from "date-fns";
+function formatDate(date, pattern) {
+  return format(date, pattern);
+}
+
+// src/dates/index.ts
+var LONG_DATE_FORMAT = "EEEE, MMMM dd, yyyy 'at' hh:mm a";
+var SHORT_DATE_FORMAT = "dd.MM.yyyy";
+var SHORT_DATETIME_FORMAT = "dd.MM.yyyy HH:mm a";
+function formattedDate(pattern, date = /* @__PURE__ */ new Date()) {
+  return formatDate(date, pattern);
+}
+function longFormattedDate(date = /* @__PURE__ */ new Date()) {
+  return formattedDate(LONG_DATE_FORMAT, date);
+}
+function shortFormattedDate(date = /* @__PURE__ */ new Date()) {
+  return formattedDate(SHORT_DATE_FORMAT, date);
+}
+function shortFormattedDateTime(date = /* @__PURE__ */ new Date()) {
+  return formattedDate(SHORT_DATETIME_FORMAT, date);
+}
+function optionalDate(date) {
+  return date ? new Date(date) : void 0;
+}
+
+// src/files/index.ts
+function guessImageMimeType(filename) {
+  const withoutQueryOrHash = filename.split(/[?#]/)[0];
+  const extension = withoutQueryOrHash.split(".").pop()?.toLowerCase();
+  switch (extension) {
+    case "png":
+      return "image/png";
+    case "jfif":
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    default:
+      return "image/png";
+  }
+}
+function isImageMimeType(mimeType) {
+  return mimeType === "image/png" || mimeType === "image/jpeg" || mimeType === "image/webp";
+}
+function escapeName(name) {
+  return name.replace(/[^a-zA-Z0-9-_.]/g, "_");
+}
+function safeFileName(filename, maxLength = 255) {
+  if (filename.length <= maxLength) return filename;
+  const dotIndex = filename.lastIndexOf(".");
+  const hasExtension = dotIndex > 0;
+  const extension = escapeName(hasExtension ? filename.slice(dotIndex) : "");
+  const name = escapeName(hasExtension ? filename.slice(0, dotIndex) : filename);
+  return name.slice(0, Math.max(0, maxLength - extension.length)) + extension;
+}
+async function downloadAndFormatImage(src, name = "image.png", mimeType = guessImageMimeType(name), quality = 1) {
+  name = safeFileName(name);
+  try {
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    await new Promise((resolve, reject) => {
+      img.onload = resolve;
+      img.onerror = reject;
+      img.src = src;
+    });
+    const canvas = document.createElement("canvas");
+    canvas.width = img.width;
+    canvas.height = img.height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Could not get canvas context");
+    }
+    ctx.drawImage(img, 0, 0);
+    const blob = await new Promise((resolve) => {
+      canvas.toBlob(resolve, mimeType, quality);
+    });
+    if (!blob) {
+      throw new Error("Could not generate blob");
+    }
+    const link = document.createElement("a");
+    const downloadUrl = URL.createObjectURL(blob);
+    try {
+      link.href = downloadUrl;
+      link.download = name;
+      document.body.appendChild(link);
+      link.click();
+    } finally {
+      document.body.removeChild(link);
+      URL.revokeObjectURL(downloadUrl);
+    }
+  } catch (error) {
+    console.error("Failed to download image:", error);
+  }
+}
+async function fileToBase64Native(file) {
+  const result = await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+  });
+  if (typeof result === "string") {
+    return result;
+  } else {
+    throw new Error("Failed to read file as Data URL");
+  }
+}
+async function fileToBase64(file, quality = 1) {
+  if (isImageMimeType(file.type)) {
+    const img = new Image();
+    const url = URL.createObjectURL(file);
+    try {
+      await new Promise((resolve, reject) => {
+        img.onload = () => resolve();
+        img.onerror = () => reject(new Error("Failed to load image for metadata removal"));
+        img.src = url;
+      });
+      const canvas = document.createElement("canvas");
+      canvas.width = img.width;
+      canvas.height = img.height;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        throw new Error("Failed to get canvas context");
+      }
+      ctx.drawImage(img, 0, 0);
+      const cleanDataUrl = canvas.toDataURL(file.type, quality);
+      if (cleanDataUrl === "data:,") {
+        return await fileToBase64Native(file);
+      }
+      return cleanDataUrl;
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  } else {
+    return await fileToBase64Native(file);
+  }
+}
+
+// src/cookies/index.ts
+function getCookie(name) {
+  for (const pair of document.cookie.split("; ")) {
+    const separatorIndex = pair.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    if (pair.slice(0, separatorIndex) === name) {
+      return pair.slice(separatorIndex + 1);
+    }
+  }
+  return void 0;
+}
+
+// src/console/index.ts
+var patchedWindows = /* @__PURE__ */ new WeakMap();
+function createConsoleDebugSwitch(targetWindow, options) {
+  if (!targetWindow) {
+    return;
+  }
+  const { namespace } = options;
+  let enabledNamespaces = patchedWindows.get(targetWindow);
+  if (!enabledNamespaces) {
+    enabledNamespaces = /* @__PURE__ */ new Set();
+    patchedWindows.set(targetWindow, enabledNamespaces);
+    const original = {
+      log: targetWindow.console.log.bind(targetWindow.console),
+      info: targetWindow.console.info.bind(targetWindow.console),
+      warn: targetWindow.console.warn.bind(targetWindow.console),
+      error: targetWindow.console.error.bind(targetWindow.console)
+    };
+    const conditional = (method) => (...args) => {
+      if (enabledNamespaces.size > 0) {
+        method(...args);
+      }
+    };
+    targetWindow.console.log = conditional(original.log);
+    targetWindow.console.info = conditional(original.info);
+    targetWindow.console.warn = conditional(original.warn);
+    targetWindow.console.error = conditional(original.error);
+  }
+  const globals = targetWindow;
+  const existing = Object.prototype.hasOwnProperty.call(globals, namespace) ? Object.getOwnPropertyDescriptor(globals, namespace)?.value : void 0;
+  const target = existing ?? {};
+  target.debug = (flag) => {
+    if (flag) {
+      enabledNamespaces.add(namespace);
+    } else {
+      enabledNamespaces.delete(namespace);
+    }
+  };
+  Object.defineProperty(globals, namespace, { value: target, writable: true, configurable: true, enumerable: true });
+}
+
+// src/colors/index.ts
+var HEX_PATTERN = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function hexToRgb(hex) {
+  const match = HEX_PATTERN.exec(hex.trim());
+  if (!match) {
+    throw new Error(`Invalid hex color: "${hex}"`);
+  }
+  const digits = match[1];
+  const normalized = digits.length === 3 ? digits.split("").map((char) => char + char).join("") : digits;
+  return {
+    r: parseInt(normalized.slice(0, 2), 16),
+    g: parseInt(normalized.slice(2, 4), 16),
+    b: parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function rgbToHex({ r, g, b }) {
+  return `#${[r, g, b].map((channel) => Math.round(channel).toString(16).padStart(2, "0")).join("")}`;
+}
+function mixRgb(base, target, weight) {
+  return {
+    r: base.r + (target.r - base.r) * weight,
+    g: base.g + (target.g - base.g) * weight,
+    b: base.b + (target.b - base.b) * weight
+  };
+}
+var WHITE = { r: 255, g: 255, b: 255 };
+var BLACK = { r: 0, g: 0, b: 0 };
+var TINT_WEIGHTS = { 50: 0.95, 100: 0.9, 200: 0.75, 300: 0.6, 400: 0.3 };
+var SHADE_WEIGHTS = {
+  600: 0.15,
+  700: 0.3,
+  800: 0.45,
+  900: 0.6,
+  950: 0.8
+};
+function generateTailwindColorScale(baseColor) {
+  const base = hexToRgb(baseColor);
+  return {
+    50: rgbToHex(mixRgb(base, WHITE, TINT_WEIGHTS[50])),
+    100: rgbToHex(mixRgb(base, WHITE, TINT_WEIGHTS[100])),
+    200: rgbToHex(mixRgb(base, WHITE, TINT_WEIGHTS[200])),
+    300: rgbToHex(mixRgb(base, WHITE, TINT_WEIGHTS[300])),
+    400: rgbToHex(mixRgb(base, WHITE, TINT_WEIGHTS[400])),
+    500: rgbToHex(base),
+    600: rgbToHex(mixRgb(base, BLACK, SHADE_WEIGHTS[600])),
+    700: rgbToHex(mixRgb(base, BLACK, SHADE_WEIGHTS[700])),
+    800: rgbToHex(mixRgb(base, BLACK, SHADE_WEIGHTS[800])),
+    900: rgbToHex(mixRgb(base, BLACK, SHADE_WEIGHTS[900])),
+    950: rgbToHex(mixRgb(base, BLACK, SHADE_WEIGHTS[950]))
+  };
+}
+function generateNamedTailwindColorScale(baseColor, name) {
+  const scale = generateTailwindColorScale(baseColor);
+  return Object.fromEntries(Object.entries(scale).map(([shade, hex]) => [`${name}${shade}`, hex]));
+}
+function rgbToHsl({ r, g, b }) {
+  const rN = r / 255;
+  const gN = g / 255;
+  const bN = b / 255;
+  const max = Math.max(rN, gN, bN);
+  const min = Math.min(rN, gN, bN);
+  const l = (max + min) / 2;
+  if (max === min) {
+    return { h: 0, s: 0, l: l * 100 };
+  }
+  const delta = max - min;
+  const s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+  let h;
+  if (max === rN) {
+    h = ((gN - bN) / delta + (gN < bN ? 6 : 0)) * 60;
+  } else if (max === gN) {
+    h = ((bN - rN) / delta + 2) * 60;
+  } else {
+    h = ((rN - gN) / delta + 4) * 60;
+  }
+  return { h, s: s * 100, l: l * 100 };
+}
+function hexToHslTriplet(hex, precision = 1) {
+  const { h, s, l } = rgbToHsl(hexToRgb(hex));
+  const round = (value) => Number(value.toFixed(precision));
+  return `${round(h)} ${round(s)}% ${round(l)}%`;
+}
+export {
+  LONG_DATE_FORMAT,
+  SHORT_DATETIME_FORMAT,
+  SHORT_DATE_FORMAT,
+  allCombinations,
+  checkRequiredKeys,
+  cloned,
+  createConsoleDebugSwitch,
+  downloadAndFormatImage,
+  enabledIf,
+  escapeName,
+  fileToBase64,
+  fileToBase64Native,
+  forcedType,
+  formattedDate,
+  generateNamedTailwindColorScale,
+  generateTailwindColorScale,
+  getCookie,
+  getKeys,
+  getLazyValue,
+  getLazyValueAsync,
+  guessImageMimeType,
+  hexToHslTriplet,
+  isImageMimeType,
+  isPathMatched,
+  longFormattedDate,
+  makeCallable,
+  notNone,
+  optionalDate,
+  preventDefault,
+  raises,
+  requireExclusiveKeys,
+  safeFileName,
+  setKeyValueToObjectIfValue,
+  shortFormattedDate,
+  shortFormattedDateTime,
+  slugify,
+  suppress,
+  transformExceptions,
+  withAttributes
+};
+//# sourceMappingURL=index.js.map