dropcap 1.0.0

package/dist/types/types.d.ts

@@ -0,0 +1,7 @@
+type Obj = Record<PropertyKey, unknown>;
+type Arr = unknown[];
+type Cls<T = any> = new (...args: any[]) => T;
+type Fn<T = any> = (...args: any[]) => T;
+type AsyncFn<T = any> = (...args: any[]) => Promise<T>;
+
+export type { Arr, AsyncFn, Cls, Fn, Obj };

package/dist/utils/utils-color-hash.d.ts

@@ -0,0 +1,4 @@
+type Rgb = [number, number, number];
+declare function colorHash(str: string): string;
+
+export { type Rgb, colorHash };

package/dist/utils/utils-color-hash.js

@@ -0,0 +1,42 @@
+// src/utils/utils-color-hash.ts
+function colorHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  hash >>>= 0;
+  const hue = Math.floor(hash * 0.618033988749895 % 1 * 360);
+  const sat = 70;
+  let light = 50;
+  for (let i = 0; i < 20; i++) {
+    const rgb = hsl2rgb(hue, sat, light);
+    const l = lum(rgb);
+    const cW = contrast(1, l);
+    const cB = contrast(0, l);
+    if (cW >= 4.5 && cB >= 4.5) break;
+    light += cW < cB ? -5 : 5;
+  }
+  const hex = hsl2rgb(hue, sat, light).map((v) => v.toString(16).padStart(2, "0")).join("");
+  return `#${hex}`;
+}
+function hsl2rgb(hh, ss, ll) {
+  ss /= 100;
+  ll /= 100;
+  const k = (n) => (n + hh / 30) % 12;
+  const a = ss * Math.min(ll, 1 - ll);
+  const f = (n) => ll - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [f(0), f(8), f(4)].map((v) => Math.round(v * 255));
+}
+function lum([r, g, b]) {
+  const c = (x) => {
+    x /= 255;
+    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b);
+}
+function contrast(l1, l2) {
+  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+}
+export {
+  colorHash
+};

package/dist/utils/utils-create-log.d.ts

@@ -0,0 +1,9 @@
+import { Fn } from '../types/types.js';
+
+type Log = Fn<void> & {
+    warn: Fn<void>;
+    error: Fn<void>;
+};
+declare function createLog(name: string): Log;
+
+export { type Log, createLog };

package/dist/utils/utils-create-log.js

@@ -0,0 +1,54 @@
+// src/utils/utils-color-hash.ts
+function colorHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  hash >>>= 0;
+  const hue = Math.floor(hash * 0.618033988749895 % 1 * 360);
+  const sat = 70;
+  let light = 50;
+  for (let i = 0; i < 20; i++) {
+    const rgb = hsl2rgb(hue, sat, light);
+    const l = lum(rgb);
+    const cW = contrast(1, l);
+    const cB = contrast(0, l);
+    if (cW >= 4.5 && cB >= 4.5) break;
+    light += cW < cB ? -5 : 5;
+  }
+  const hex = hsl2rgb(hue, sat, light).map((v) => v.toString(16).padStart(2, "0")).join("");
+  return `#${hex}`;
+}
+function hsl2rgb(hh, ss, ll) {
+  ss /= 100;
+  ll /= 100;
+  const k = (n) => (n + hh / 30) % 12;
+  const a = ss * Math.min(ll, 1 - ll);
+  const f = (n) => ll - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [f(0), f(8), f(4)].map((v) => Math.round(v * 255));
+}
+function lum([r, g, b]) {
+  const c = (x) => {
+    x /= 255;
+    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b);
+}
+function contrast(l1, l2) {
+  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+}
+
+// src/utils/utils-create-log.ts
+function createLog(name) {
+  const color = colorHash(name);
+  const log = print.bind(null, "log", name, color);
+  log.warn = print.bind(null, "warn", name, color);
+  log.error = print.bind(null, "error", name, color);
+  return log;
+}
+function print(type, name, color, ...args) {
+  console[type](`%c[${name}]`, `color: ${color}`, ...args);
+}
+export {
+  createLog
+};

package/dist/utils/utils-ensure-array.d.ts

@@ -0,0 +1,3 @@
+declare function ensureArray<T>(value: T | T[]): T[];
+
+export { ensureArray };

package/dist/utils/utils-ensure-array.js

@@ -0,0 +1,7 @@
+// src/utils/utils-ensure-array.ts
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+export {
+  ensureArray
+};

package/dist/utils/utils-is.d.ts

@@ -0,0 +1,33 @@
+import { Fn, Obj, Arr } from '../types/types.js';
+
+declare const is: {
+    null: (v: unknown) => v is null;
+    undefined: (v: unknown) => v is undefined;
+    boolean: (v: unknown) => v is boolean;
+    number: (v: unknown) => v is number;
+    string: (v: unknown) => v is string;
+    symbol: (v: unknown) => v is symbol;
+    function: (v: unknown) => v is Fn;
+    object: (v: unknown) => v is Obj;
+    array: (v: unknown) => v is Arr;
+    set: (v: unknown) => v is Set<any>;
+    map: (v: unknown) => v is Map<any, any>;
+    blob: (v: unknown) => v is Blob;
+    date: (v: unknown) => v is Date;
+    error: (v: unknown) => v is Error;
+    regex: (v: unknown) => v is RegExp;
+    promise: (v: unknown) => v is Promise<any>;
+    uint8Array: (v: unknown) => v is Uint8Array<ArrayBufferLike>;
+    uint16Array: (v: unknown) => v is Uint16Array<ArrayBufferLike>;
+    uint32Array: (v: unknown) => v is Uint32Array<ArrayBufferLike>;
+    nan: (v: unknown) => boolean;
+    numeric: (v: unknown) => boolean;
+    integer: (v: unknown) => v is number;
+    absent: (v: unknown) => v is null | undefined;
+    present: <T>(v: T) => v is NonNullable<T>;
+    primitive: (v: unknown) => boolean;
+    collection: (v: unknown) => v is Obj | Arr;
+    compound: (v: unknown) => v is object;
+};
+
+export { is };

package/dist/utils/utils-is.js

@@ -0,0 +1,33 @@
+// src/utils/utils-is.ts
+var is = {
+  null: (v) => v === null,
+  undefined: (v) => v === void 0,
+  boolean: (v) => typeof v === "boolean",
+  number: (v) => typeof v === "number",
+  string: (v) => typeof v === "string",
+  symbol: (v) => typeof v === "symbol",
+  function: (v) => typeof v === "function",
+  object: (v) => Object.prototype.toString.call(v) === "[object Object]",
+  array: (v) => Array.isArray(v),
+  set: (v) => v instanceof Set,
+  map: (v) => v instanceof Map,
+  blob: (v) => v instanceof Blob,
+  date: (v) => v instanceof Date,
+  error: (v) => v instanceof Error,
+  regex: (v) => v instanceof RegExp,
+  promise: (v) => v instanceof Promise,
+  uint8Array: (v) => v instanceof Uint8Array,
+  uint16Array: (v) => v instanceof Uint16Array,
+  uint32Array: (v) => v instanceof Uint32Array,
+  nan: (v) => Number.isNaN(v),
+  numeric: (v) => !is.nan(Number(v)),
+  integer: (v) => Number.isInteger(v),
+  absent: (v) => v === null || v === void 0,
+  present: (v) => !is.absent(v),
+  primitive: (v) => v !== Object(v),
+  collection: (v) => is.array(v) || is.object(v),
+  compound: (v) => v !== null && typeof v === "object"
+};
+export {
+  is
+};

package/dist/utils/utils-queue.d.ts

@@ -0,0 +1,20 @@
+import { AsyncFn } from '../types/types.js';
+
+type TaskFn<T> = () => Promise<T>;
+type Task<T = any> = {
+    fn: TaskFn<T>;
+    result$: PromiseWithResolvers<T>;
+};
+declare class Queue {
+    name: string | null;
+    tasks: Task[];
+    private running;
+    constructor(name?: string | null);
+    add<T>(fn: TaskFn<T>): Promise<T>;
+    wrap<T extends AsyncFn>(fn: T, thisValue?: unknown): (...args: Parameters<T>) => Promise<any>;
+    wait(): Promise<void>;
+    isEmpty(): boolean;
+    private start;
+}
+
+export { Queue };

package/dist/utils/utils-queue.js

@@ -0,0 +1,88 @@
+// src/utils/utils-is.ts
+var is = {
+  null: (v) => v === null,
+  undefined: (v) => v === void 0,
+  boolean: (v) => typeof v === "boolean",
+  number: (v) => typeof v === "number",
+  string: (v) => typeof v === "string",
+  symbol: (v) => typeof v === "symbol",
+  function: (v) => typeof v === "function",
+  object: (v) => Object.prototype.toString.call(v) === "[object Object]",
+  array: (v) => Array.isArray(v),
+  set: (v) => v instanceof Set,
+  map: (v) => v instanceof Map,
+  blob: (v) => v instanceof Blob,
+  date: (v) => v instanceof Date,
+  error: (v) => v instanceof Error,
+  regex: (v) => v instanceof RegExp,
+  promise: (v) => v instanceof Promise,
+  uint8Array: (v) => v instanceof Uint8Array,
+  uint16Array: (v) => v instanceof Uint16Array,
+  uint32Array: (v) => v instanceof Uint32Array,
+  nan: (v) => Number.isNaN(v),
+  numeric: (v) => !is.nan(Number(v)),
+  integer: (v) => Number.isInteger(v),
+  absent: (v) => v === null || v === void 0,
+  present: (v) => !is.absent(v),
+  primitive: (v) => v !== Object(v),
+  collection: (v) => is.array(v) || is.object(v),
+  compound: (v) => v !== null && typeof v === "object"
+};
+
+// src/utils/utils-safe.ts
+async function safe(effect) {
+  try {
+    const result = is.function(effect) ? await effect() : await effect;
+    return [result, null];
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    return [null, error];
+  }
+}
+
+// src/utils/utils-queue.ts
+var Queue = class {
+  name;
+  tasks = [];
+  running = false;
+  constructor(name = null) {
+    this.name = name;
+  }
+  async add(fn) {
+    const task = { fn, result$: Promise.withResolvers() };
+    this.tasks.push(task);
+    this.start();
+    return await task.result$.promise;
+  }
+  wrap(fn, thisValue = null) {
+    return async (...args) => {
+      return await this.add(() => fn.call(thisValue, ...args));
+    };
+  }
+  async wait() {
+    const lastTask = this.tasks.at(-1);
+    if (lastTask) await safe(lastTask.result$.promise);
+  }
+  isEmpty() {
+    return this.tasks.length === 0;
+  }
+  async start() {
+    if (this.running) return;
+    if (this.isEmpty()) return;
+    this.running = true;
+    while (this.tasks.length > 0) {
+      const task = this.tasks[0];
+      const [result, error] = await safe(task.fn);
+      this.tasks.shift();
+      if (error) {
+        task.result$.reject(error);
+      } else {
+        task.result$.resolve(result);
+      }
+    }
+    this.running = false;
+  }
+};
+export {
+  Queue
+};

package/dist/utils/utils-safe.d.ts

@@ -0,0 +1,4 @@
+declare function safe<T>(effect: (() => T | Promise<T>) | Promise<T>): Promise<[T, null] | [null, Error]>;
+declare function safeSync<T>(effect: () => T): [T, null] | [null, Error];
+
+export { safe, safeSync };

package/dist/utils/utils-safe.js

@@ -0,0 +1,54 @@
+// src/utils/utils-is.ts
+var is = {
+  null: (v) => v === null,
+  undefined: (v) => v === void 0,
+  boolean: (v) => typeof v === "boolean",
+  number: (v) => typeof v === "number",
+  string: (v) => typeof v === "string",
+  symbol: (v) => typeof v === "symbol",
+  function: (v) => typeof v === "function",
+  object: (v) => Object.prototype.toString.call(v) === "[object Object]",
+  array: (v) => Array.isArray(v),
+  set: (v) => v instanceof Set,
+  map: (v) => v instanceof Map,
+  blob: (v) => v instanceof Blob,
+  date: (v) => v instanceof Date,
+  error: (v) => v instanceof Error,
+  regex: (v) => v instanceof RegExp,
+  promise: (v) => v instanceof Promise,
+  uint8Array: (v) => v instanceof Uint8Array,
+  uint16Array: (v) => v instanceof Uint16Array,
+  uint32Array: (v) => v instanceof Uint32Array,
+  nan: (v) => Number.isNaN(v),
+  numeric: (v) => !is.nan(Number(v)),
+  integer: (v) => Number.isInteger(v),
+  absent: (v) => v === null || v === void 0,
+  present: (v) => !is.absent(v),
+  primitive: (v) => v !== Object(v),
+  collection: (v) => is.array(v) || is.object(v),
+  compound: (v) => v !== null && typeof v === "object"
+};
+
+// src/utils/utils-safe.ts
+async function safe(effect) {
+  try {
+    const result = is.function(effect) ? await effect() : await effect;
+    return [result, null];
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    return [null, error];
+  }
+}
+function safeSync(effect) {
+  try {
+    const result = effect();
+    return [result, null];
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    return [null, error];
+  }
+}
+export {
+  safe,
+  safeSync
+};

package/dist/utils/utils-unique.d.ts

@@ -0,0 +1,3 @@
+declare function unique<T = unknown>(items: T[], keyFn?: (item: T) => unknown): T[];
+
+export { unique };

package/dist/utils/utils-unique.js

@@ -0,0 +1,14 @@
+// src/utils/utils-unique.ts
+function unique(items, keyFn) {
+  if (!keyFn) return [...new Set(items)];
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+export {
+  unique
+};

package/dist/utils/utils-unit.d.ts

@@ -0,0 +1,14 @@
+import { Log } from './utils-create-log.js';
+import { Cls } from '../types/types.js';
+
+declare class Unit<TRoot = unknown> {
+    #private;
+    $: TRoot;
+    log: Log;
+    constructor(parent?: Unit<TRoot> | null);
+    closest<T extends Unit<TRoot>>(Ancestor: Cls<T>): T | null;
+    never(message?: string): Error;
+    Error(message?: string): Error;
+}
+
+export { Unit };

package/dist/utils/utils-unit.js

@@ -0,0 +1,84 @@
+// src/utils/utils-color-hash.ts
+function colorHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  hash >>>= 0;
+  const hue = Math.floor(hash * 0.618033988749895 % 1 * 360);
+  const sat = 70;
+  let light = 50;
+  for (let i = 0; i < 20; i++) {
+    const rgb = hsl2rgb(hue, sat, light);
+    const l = lum(rgb);
+    const cW = contrast(1, l);
+    const cB = contrast(0, l);
+    if (cW >= 4.5 && cB >= 4.5) break;
+    light += cW < cB ? -5 : 5;
+  }
+  const hex = hsl2rgb(hue, sat, light).map((v) => v.toString(16).padStart(2, "0")).join("");
+  return `#${hex}`;
+}
+function hsl2rgb(hh, ss, ll) {
+  ss /= 100;
+  ll /= 100;
+  const k = (n) => (n + hh / 30) % 12;
+  const a = ss * Math.min(ll, 1 - ll);
+  const f = (n) => ll - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [f(0), f(8), f(4)].map((v) => Math.round(v * 255));
+}
+function lum([r, g, b]) {
+  const c = (x) => {
+    x /= 255;
+    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b);
+}
+function contrast(l1, l2) {
+  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+}
+
+// src/utils/utils-create-log.ts
+function createLog(name) {
+  const color = colorHash(name);
+  const log = print.bind(null, "log", name, color);
+  log.warn = print.bind(null, "warn", name, color);
+  log.error = print.bind(null, "error", name, color);
+  return log;
+}
+function print(type, name, color, ...args) {
+  console[type](`%c[${name}]`, `color: ${color}`, ...args);
+}
+
+// src/utils/utils-unit.ts
+var Unit = class {
+  $;
+  log = createLog(this.constructor.name);
+  #parent = null;
+  constructor(parent) {
+    this.$ = parent?.$ ?? this;
+    this.#parent = parent ?? null;
+  }
+  closest(Ancestor) {
+    let cursor = this.#parent;
+    while (cursor) {
+      if (cursor instanceof Ancestor) return cursor;
+      cursor = cursor.#parent;
+    }
+    return null;
+  }
+  never(message) {
+    const details = message ? `: ${message}` : "";
+    const error = new Error(`[${this.constructor.name}] This should never happen${details}`);
+    Error.captureStackTrace(error, this.never);
+    return error;
+  }
+  Error(message) {
+    const error = new Error(`[${this.constructor.name}] ${message}`);
+    Error.captureStackTrace(error, this.Error);
+    return error;
+  }
+};
+export {
+  Unit
+};

package/dist/utils/utils-wait.d.ts

@@ -0,0 +1,3 @@
+declare function wait(ms: number): Promise<void>;
+
+export { wait };

package/dist/utils/utils-wait.js

@@ -0,0 +1,7 @@
+// src/utils/utils-wait.ts
+async function wait(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+export {
+  wait
+};

package/dist/utils/utils.d.ts

@@ -0,0 +1,10 @@
+export { colorHash } from './utils-color-hash.js';
+export { Log, createLog } from './utils-create-log.js';
+export { ensureArray } from './utils-ensure-array.js';
+export { is } from './utils-is.js';
+export { Queue } from './utils-queue.js';
+export { safe, safeSync } from './utils-safe.js';
+export { unique } from './utils-unique.js';
+export { Unit } from './utils-unit.js';
+export { wait } from './utils-wait.js';
+import '../types/types.js';

package/dist/utils/utils.js

@@ -0,0 +1,210 @@
+// src/utils/utils-color-hash.ts
+function colorHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  hash >>>= 0;
+  const hue = Math.floor(hash * 0.618033988749895 % 1 * 360);
+  const sat = 70;
+  let light = 50;
+  for (let i = 0; i < 20; i++) {
+    const rgb = hsl2rgb(hue, sat, light);
+    const l = lum(rgb);
+    const cW = contrast(1, l);
+    const cB = contrast(0, l);
+    if (cW >= 4.5 && cB >= 4.5) break;
+    light += cW < cB ? -5 : 5;
+  }
+  const hex = hsl2rgb(hue, sat, light).map((v) => v.toString(16).padStart(2, "0")).join("");
+  return `#${hex}`;
+}
+function hsl2rgb(hh, ss, ll) {
+  ss /= 100;
+  ll /= 100;
+  const k = (n) => (n + hh / 30) % 12;
+  const a = ss * Math.min(ll, 1 - ll);
+  const f = (n) => ll - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [f(0), f(8), f(4)].map((v) => Math.round(v * 255));
+}
+function lum([r, g, b]) {
+  const c = (x) => {
+    x /= 255;
+    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b);
+}
+function contrast(l1, l2) {
+  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+}
+
+// src/utils/utils-create-log.ts
+function createLog(name) {
+  const color = colorHash(name);
+  const log = print.bind(null, "log", name, color);
+  log.warn = print.bind(null, "warn", name, color);
+  log.error = print.bind(null, "error", name, color);
+  return log;
+}
+function print(type, name, color, ...args) {
+  console[type](`%c[${name}]`, `color: ${color}`, ...args);
+}
+
+// src/utils/utils-ensure-array.ts
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/utils/utils-is.ts
+var is = {
+  null: (v) => v === null,
+  undefined: (v) => v === void 0,
+  boolean: (v) => typeof v === "boolean",
+  number: (v) => typeof v === "number",
+  string: (v) => typeof v === "string",
+  symbol: (v) => typeof v === "symbol",
+  function: (v) => typeof v === "function",
+  object: (v) => Object.prototype.toString.call(v) === "[object Object]",
+  array: (v) => Array.isArray(v),
+  set: (v) => v instanceof Set,
+  map: (v) => v instanceof Map,
+  blob: (v) => v instanceof Blob,
+  date: (v) => v instanceof Date,
+  error: (v) => v instanceof Error,
+  regex: (v) => v instanceof RegExp,
+  promise: (v) => v instanceof Promise,
+  uint8Array: (v) => v instanceof Uint8Array,
+  uint16Array: (v) => v instanceof Uint16Array,
+  uint32Array: (v) => v instanceof Uint32Array,
+  nan: (v) => Number.isNaN(v),
+  numeric: (v) => !is.nan(Number(v)),
+  integer: (v) => Number.isInteger(v),
+  absent: (v) => v === null || v === void 0,
+  present: (v) => !is.absent(v),
+  primitive: (v) => v !== Object(v),
+  collection: (v) => is.array(v) || is.object(v),
+  compound: (v) => v !== null && typeof v === "object"
+};
+
+// src/utils/utils-safe.ts
+async function safe(effect) {
+  try {
+    const result = is.function(effect) ? await effect() : await effect;
+    return [result, null];
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    return [null, error];
+  }
+}
+function safeSync(effect) {
+  try {
+    const result = effect();
+    return [result, null];
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    return [null, error];
+  }
+}
+
+// src/utils/utils-queue.ts
+var Queue = class {
+  name;
+  tasks = [];
+  running = false;
+  constructor(name = null) {
+    this.name = name;
+  }
+  async add(fn) {
+    const task = { fn, result$: Promise.withResolvers() };
+    this.tasks.push(task);
+    this.start();
+    return await task.result$.promise;
+  }
+  wrap(fn, thisValue = null) {
+    return async (...args) => {
+      return await this.add(() => fn.call(thisValue, ...args));
+    };
+  }
+  async wait() {
+    const lastTask = this.tasks.at(-1);
+    if (lastTask) await safe(lastTask.result$.promise);
+  }
+  isEmpty() {
+    return this.tasks.length === 0;
+  }
+  async start() {
+    if (this.running) return;
+    if (this.isEmpty()) return;
+    this.running = true;
+    while (this.tasks.length > 0) {
+      const task = this.tasks[0];
+      const [result, error] = await safe(task.fn);
+      this.tasks.shift();
+      if (error) {
+        task.result$.reject(error);
+      } else {
+        task.result$.resolve(result);
+      }
+    }
+    this.running = false;
+  }
+};
+
+// src/utils/utils-unique.ts
+function unique(items, keyFn) {
+  if (!keyFn) return [...new Set(items)];
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/utils/utils-unit.ts
+var Unit = class {
+  $;
+  log = createLog(this.constructor.name);
+  #parent = null;
+  constructor(parent) {
+    this.$ = parent?.$ ?? this;
+    this.#parent = parent ?? null;
+  }
+  closest(Ancestor) {
+    let cursor = this.#parent;
+    while (cursor) {
+      if (cursor instanceof Ancestor) return cursor;
+      cursor = cursor.#parent;
+    }
+    return null;
+  }
+  never(message) {
+    const details = message ? `: ${message}` : "";
+    const error = new Error(`[${this.constructor.name}] This should never happen${details}`);
+    Error.captureStackTrace(error, this.never);
+    return error;
+  }
+  Error(message) {
+    const error = new Error(`[${this.constructor.name}] ${message}`);
+    Error.captureStackTrace(error, this.Error);
+    return error;
+  }
+};
+
+// src/utils/utils-wait.ts
+async function wait(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+export {
+  Queue,
+  Unit,
+  colorHash,
+  createLog,
+  ensureArray,
+  is,
+  safe,
+  safeSync,
+  unique,
+  wait
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "dropcap",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "MIT",
+  "author": "imkost",
+  "description": "",
+  "scripts": {
+    "dev": "tsup --config ../../tsup.config.ts --watch",
+    "build": "tsup --config ../../tsup.config.ts",
+    "lint": "tsc --noEmit",
+    "release": "sh -c 'npm version ${1:-minor} && npm run build && npm publish' --"
+  },
+  "exports": {
+    "./utils": {
+      "source": "./src/utils/utils.ts",
+      "import": "./dist/utils/utils.js",
+      "types": "./dist/utils/utils.d.ts"
+    },
+    "./types": {
+      "source": "./src/types/types.ts",
+      "import": "./dist/types/types.js",
+      "types": "./dist/types/types.d.ts"
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ]
+}

package/src/types/types.ts

@@ -0,0 +1,5 @@
+export type Obj = Record<PropertyKey, unknown>
+export type Arr = unknown[]
+export type Cls<T = any> = new (...args: any[]) => T
+export type Fn<T = any> = (...args: any[]) => T
+export type AsyncFn<T = any> = (...args: any[]) => Promise<T>

package/src/utils/utils-color-hash.ts

@@ -0,0 +1,55 @@
+export type Rgb = [number, number, number]
+
+export function colorHash(str: string) {
+  // Calculate hash (djb2 xor) as 32‑bit unsigned
+  let hash = 5381
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash * 33) ^ str.charCodeAt(i)
+  }
+  hash >>>= 0
+
+  // Calculate hue. Golden‑ratio scramble gives maximum spread for 'near' strings.
+  const hue = Math.floor(((hash * 0.618033988749895) % 1) * 360)
+
+  // Start with vivid mid‑tone
+  const sat = 70
+  let light = 50
+
+  // Adjust lightness until it reads on both white and black backgrounds.
+  for (let i = 0; i < 20; i++) {
+    const rgb = hsl2rgb(hue, sat, light)
+    const l = lum(rgb)
+    const cW = contrast(1, l) // Versus white
+    const cB = contrast(0, l) // Versus black
+    if (cW >= 4.5 && cB >= 4.5) break // Good on both
+    light += cW < cB ? -5 : 5 // Move toward darker or lighter
+  }
+
+  // Convert to hex
+  const hex = hsl2rgb(hue, sat, light)
+    .map(v => v.toString(16).padStart(2, '0'))
+    .join('')
+
+  return `#${hex}`
+}
+
+function hsl2rgb(hh: number, ss: number, ll: number): Rgb {
+  ss /= 100
+  ll /= 100
+  const k = (n: number) => (n + hh / 30) % 12
+  const a = ss * Math.min(ll, 1 - ll)
+  const f = (n: number) => ll - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)))
+  return [f(0), f(8), f(4)].map(v => Math.round(v * 255)) as Rgb
+}
+
+function lum([r, g, b]: Rgb) {
+  const c = (x: number) => {
+    x /= 255
+    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4
+  }
+  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b)
+}
+
+function contrast(l1: number, l2: number) {
+  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05)
+}

package/src/utils/utils-create-log.ts

@@ -0,0 +1,16 @@
+import type { Fn } from '../types/types.js'
+import { colorHash } from './utils-color-hash.js'
+
+export type Log = Fn<void> & { warn: Fn<void>; error: Fn<void> }
+
+export function createLog(name: string) {
+  const color = colorHash(name)
+  const log = print.bind(null, 'log', name, color) as Log
+  log.warn = print.bind(null, 'warn', name, color) as Log['warn']
+  log.error = print.bind(null, 'error', name, color) as Log['error']
+  return log
+}
+
+function print(type: 'log' | 'warn' | 'error', name: string, color: string, ...args: unknown[]) {
+  console[type](`%c[${name}]`, `color: ${color}`, ...args)
+}

package/src/utils/utils-ensure-array.ts

@@ -0,0 +1,3 @@
+export function ensureArray<T>(value: T | T[]): T[] {
+  return Array.isArray(value) ? value : [value]
+}

package/src/utils/utils-is.ts

@@ -0,0 +1,32 @@
+import type { Fn, Obj, Arr } from '../types/types.js'
+
+export const is = {
+  null: (v: unknown) => v === null,
+  undefined: (v: unknown) => v === undefined,
+  boolean: (v: unknown) => typeof v === 'boolean',
+  number: (v: unknown) => typeof v === 'number',
+  string: (v: unknown) => typeof v === 'string',
+  symbol: (v: unknown) => typeof v === 'symbol',
+  function: (v: unknown): v is Fn => typeof v === 'function',
+  object: (v: unknown): v is Obj => Object.prototype.toString.call(v) === '[object Object]',
+  array: (v: unknown): v is Arr => Array.isArray(v),
+  set: (v: unknown) => v instanceof Set,
+  map: (v: unknown) => v instanceof Map,
+  blob: (v: unknown) => v instanceof Blob,
+  date: (v: unknown) => v instanceof Date,
+  error: (v: unknown) => v instanceof Error,
+  regex: (v: unknown) => v instanceof RegExp,
+  promise: (v: unknown) => v instanceof Promise,
+  uint8Array: (v: unknown) => v instanceof Uint8Array,
+  uint16Array: (v: unknown) => v instanceof Uint16Array,
+  uint32Array: (v: unknown) => v instanceof Uint32Array,
+
+  nan: (v: unknown) => Number.isNaN(v),
+  numeric: (v: unknown) => !is.nan(Number(v)),
+  integer: (v: unknown): v is number => Number.isInteger(v),
+  absent: (v: unknown) => v === null || v === undefined,
+  present: <T>(v: T): v is NonNullable<T> => !is.absent(v),
+  primitive: (v: unknown) => v !== Object(v),
+  collection: (v: unknown) => is.array(v) || is.object(v),
+  compound: (v: unknown) => v !== null && typeof v === 'object',
+}

package/src/utils/utils-queue.ts

@@ -0,0 +1,57 @@
+import { safe } from './utils-safe.js'
+import type { AsyncFn } from '../types/types.js'
+
+type TaskFn<T> = () => Promise<T>
+type Task<T = any> = { fn: TaskFn<T>; result$: PromiseWithResolvers<T> }
+
+export class Queue {
+  name: string | null
+  tasks: Task[] = []
+  private running = false
+
+  constructor(name: string | null = null) {
+    this.name = name
+  }
+
+  async add<T>(fn: TaskFn<T>): Promise<T> {
+    const task: Task<T> = { fn, result$: Promise.withResolvers<T>() }
+    this.tasks.push(task)
+    this.start()
+    return await task.result$.promise
+  }
+
+  wrap<T extends AsyncFn>(fn: T, thisValue: unknown = null) {
+    return async (...args: Parameters<T>) => {
+      return await this.add(() => fn.call(thisValue, ...args))
+    }
+  }
+
+  async wait() {
+    const lastTask = this.tasks.at(-1)
+    if (lastTask) await safe(lastTask.result$.promise)
+  }
+
+  isEmpty() {
+    return this.tasks.length === 0
+  }
+
+  private async start() {
+    if (this.running) return
+    if (this.isEmpty()) return
+
+    this.running = true
+
+    while (this.tasks.length > 0) {
+      const task = this.tasks[0]
+      const [result, error] = await safe(task.fn)
+      this.tasks.shift()
+      if (error) {
+        task.result$.reject(error)
+      } else {
+        task.result$.resolve(result)
+      }
+    }
+
+    this.running = false
+  }
+}

package/src/utils/utils-safe.ts

@@ -0,0 +1,23 @@
+import { is } from './utils-is.js'
+
+export async function safe<T>(
+  effect: (() => T | Promise<T>) | Promise<T>,
+): Promise<[T, null] | [null, Error]> {
+  try {
+    const result = is.function(effect) ? await effect() : await effect
+    return [result, null]
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e))
+    return [null, error]
+  }
+}
+
+export function safeSync<T>(effect: () => T): [T, null] | [null, Error] {
+  try {
+    const result = effect()
+    return [result, null]
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e))
+    return [null, error]
+  }
+}

package/src/utils/utils-unique.ts

@@ -0,0 +1,11 @@
+export function unique<T = unknown>(items: T[], keyFn?: (item: T) => unknown) {
+  if (!keyFn) return [...new Set(items)]
+
+  const seen = new Set()
+  return items.filter(item => {
+    const key = keyFn(item)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}

package/src/utils/utils-unit.ts

@@ -0,0 +1,35 @@
+import type { Cls } from '../types/types.js'
+import { createLog } from './utils-create-log.js'
+
+export class Unit<TRoot = unknown> {
+  $: TRoot
+  log = createLog(this.constructor.name)
+  #parent: Unit<TRoot> | null = null
+
+  constructor(parent?: Unit<TRoot> | null) {
+    this.$ = (parent?.$ ?? this) as TRoot
+    this.#parent = parent ?? null
+  }
+
+  closest<T extends Unit<TRoot>>(Ancestor: Cls<T>): T | null {
+    let cursor = this.#parent
+    while (cursor) {
+      if (cursor instanceof Ancestor) return cursor as T
+      cursor = cursor.#parent
+    }
+    return null
+  }
+
+  never(message?: string) {
+    const details = message ? `: ${message}` : ''
+    const error = new Error(`[${this.constructor.name}] This should never happen${details}`)
+    Error.captureStackTrace(error, this.never)
+    return error
+  }
+
+  Error(message?: string) {
+    const error = new Error(`[${this.constructor.name}] ${message}`)
+    Error.captureStackTrace(error, this.Error)
+    return error
+  }
+}

package/src/utils/utils-wait.ts

@@ -0,0 +1,3 @@
+export async function wait(ms: number) {
+  await new Promise(r => setTimeout(r, ms))
+}

package/src/utils/utils.ts

@@ -0,0 +1,13 @@
+import { colorHash } from './utils-color-hash.js'
+import { createLog, type Log } from './utils-create-log.js'
+import { ensureArray } from './utils-ensure-array.js'
+import { is } from './utils-is.js'
+import { Queue } from './utils-queue.js'
+import { safe, safeSync } from './utils-safe.js'
+import { unique } from './utils-unique.js'
+import { Unit } from './utils-unit.js'
+import { wait } from './utils-wait.js'
+
+export type { Log }
+
+export { colorHash, createLog, ensureArray, is, Queue, safe, safeSync, unique, Unit, wait }