@kikiutils/shared 18.3.0 → 19.0.0

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["NodeBlob","NodeFile"],"sources":["../../src/types/index.ts"],"mappings":";;;;;;YAWY,YAAY;;;;YAKZ,cAAc,cAAc,OAAO,SAAS,OAAOA,SAAWC,SAAW;;;;YAKzE;;;;YAKA,aAAa,KAAK,QAAQ,KAAK;;;;YAK/B,cAAc,KAAK,SAAS,KAAK;;;;YAKjC;;;;YAKA,cAAc,qBAAqB,KAAK,QAAQ,OAAO,GAAG;;;;YAK1D,sBAAsB,qBAAqB,KAAK,SAAS,cAAc,GAAG;;;;YAK1E,eAAe,qBAAqB,KAAK,SAAS,OAAO,GAAG"}
+{"version":3,"file":"index.d.ts","names":["NodeBlob","NodeFile"],"sources":["../../src/types/index.ts"],"mappings":";;;;;YAWY,cAAc,cAAc,OAAO,SAAS,OAAOA,SAAWC,SAAW;;;;YAKzE;;;;YAKA,aAAa,KAAK,QAAQ,KAAK;;;;YAK/B,cAAc,KAAK,SAAS,KAAK;;;;YAKjC,cAAc,qBAAqB,KAAK,QAAQ,OAAO,GAAG;;;;YAK1D,sBAAsB,qBAAqB,KAAK,SAAS,cAAc,GAAG;;;;YAK1E,eAAe,qBAAqB,KAAK,SAAS,OAAO,GAAG"}

package/dist/types/vue.d.ts

@@ -1,5 +1,4 @@
 import { GlobalComponents } from "vue";
-//#region src/types/vue.d.ts
 /**
  * A nullable reference to an instance of a globally registered Vue component.
  *
@@ -15,5 +14,4 @@ import { GlobalComponents } from "vue";
  * ```
  */
 export type ComponentRef<K extends keyof GlobalComponents> = InstanceType<GlobalComponents[K]> | null;
-//#endregion
 //# sourceMappingURL=vue.d.ts.map

package/dist/types/vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue.d.ts","names":[],"sources":["../../src/types/vue.ts"],"mappings":";;;;;;;;;;;;;;;;YAgBY,aAAa,gBAAgB,oBAAoB,aAAa,iBAAiB"}
+{"version":3,"file":"vue.d.ts","names":[],"sources":["../../src/types/vue.ts"],"mappings":";;;;;;;;;;;;;;;YAgBY,aAAa,gBAAgB,oBAAoB,aAAa,iBAAiB"}

package/dist/url.d.ts

@@ -1,4 +1,3 @@
-//#region src/url.d.ts
 /**
  * Appends or updates the `redirect` query parameter on a given URL.
  *
@@ -39,5 +38,4 @@ export declare function isSafeRedirectPath(value: unknown): value is string;
  * @returns The validated input path, or the unvalidated fallback path.
  */
 export declare function normalizeRedirectPath(value: unknown, fallback?: string): string;
-//#endregion
 //# sourceMappingURL=url.d.ts.map

package/dist/url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url.d.ts","names":[],"sources":["../src/url.ts"],"mappings":";;;;;;;;;;;;;;wBAagB,yBAAyB,aAAa;;;;;;;;;;;;;wBAwBtC,mBAAmB,iBAAiB;;;;;;;;;;;;;wBAoBpC,sBAAsB,gBAAgB"}
+{"version":3,"file":"url.d.ts","names":[],"sources":["../src/url.ts"],"mappings":";;;;;;;;;;;;;wBAagB,yBAAyB,aAAa;;;;;;;;;;;;;wBAwBtC,mBAAmB,iBAAiB;;;;;;;;;;;;;wBAoBpC,sBAAsB,gBAAgB"}

package/dist/url.js

@@ -1,4 +1,4 @@
-//#region src/url.ts
+// src/url.ts
 /**
 * Appends or updates the `redirect` query parameter on a given URL.
 *
@@ -56,7 +56,6 @@ function normalizeRedirectPath(value, fallback = "/") {
 	const redirectPath = Array.isArray(value) ? value[0] : value;
 	return isSafeRedirectPath(redirectPath) ? redirectPath : fallback;
 }
-//#endregion
 export { appendRedirectParamToUrl, isSafeRedirectPath, normalizeRedirectPath };
 
 //# sourceMappingURL=url.js.map

package/dist/vue.d.ts

@@ -1,5 +1,4 @@
 import { Ref } from "vue";
-//#region src/vue.d.ts
 /**
  * Appends the current Vue Router route's `fullPath` as the `redirect` query parameter to the given URL.
  *
@@ -34,5 +33,4 @@ export declare function clearTimeoutRef(timeoutRef: Ref<null | ReturnType<typeof
  * @param containerRef - The reference to the scrollable element, or `null` while it is unavailable.
  */
 export declare function usePreserveScroll<T extends Element = HTMLElement>(containerRef: Ref<null | T>): void;
-//#endregion
 //# sourceMappingURL=vue.d.ts.map

package/dist/vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue.d.ts","names":[],"sources":["../src/vue.ts"],"mappings":";;;;;;;;;wBAgBgB,yCAAyC;;;;;;wBASzC,iBAAiB,aAAa,WAAW,kBAAkB;;;;;;wBAU3D,gBAAgB,YAAY,WAAW,kBAAkB;;;;;;;;;;;;;;wBAkBzD,kBAAkB,UAAU,UAAU,aAAa,cAAc,WAAW"}
+{"version":3,"file":"vue.d.ts","names":[],"sources":["../src/vue.ts"],"mappings":";;;;;;;;wBAgBgB,yCAAyC;;;;;;wBASzC,iBAAiB,aAAa,WAAW,kBAAkB;;;;;;wBAU3D,gBAAgB,YAAY,WAAW,kBAAkB;;;;;;;;;;;;;;wBAkBzD,kBAAkB,UAAU,UAAU,aAAa,cAAc,WAAW"}

package/dist/vue.js

@@ -1,7 +1,7 @@
 import { appendRedirectParamToUrl } from "./url.js";
 import { onActivated } from "vue";
 import { onBeforeRouteLeave, useRoute } from "vue-router";
-//#region src/vue.ts
+// src/vue.ts
 /**
 * Appends the current Vue Router route's `fullPath` as the `redirect` query parameter to the given URL.
 *
@@ -56,7 +56,6 @@ function usePreserveScroll(containerRef) {
 		scrollTop = containerRef.value?.scrollTop || 0;
 	});
 }
-//#endregion
 export { appendRedirectParamFromCurrentRouteToUrl, clearIntervalRef, clearTimeoutRef, usePreserveScroll };
 
 //# sourceMappingURL=vue.js.map

package/dist/web.d.ts

@@ -1,4 +1,3 @@
-//#region src/web.d.ts
 /**
  * Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.
  *
@@ -22,5 +21,4 @@ export declare function appendRedirectParamFromCurrentLocationToUrl(url: string)
  * when navigation is immediate.
  */
 export declare function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number): NodeJS.Timeout | undefined;
-//#endregion
 //# sourceMappingURL=web.d.ts.map

package/dist/web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","names":[],"sources":["../src/web.ts"],"mappings":";;;;;;;;wBASgB,4CAA4C;;;;;;;;;;;;;;;wBAmB5C,8CAA8C,aAAa,mBAAgB,OAAA"}
+{"version":3,"file":"web.d.ts","names":[],"sources":["../src/web.ts"],"mappings":";;;;;;;wBASgB,4CAA4C;;;;;;;;;;;;;;;wBAmB5C,8CAA8C,aAAa,mBAAgB,OAAA"}

package/dist/web.js

@@ -1,5 +1,5 @@
 import { appendRedirectParamToUrl } from "./url.js";
-//#region src/web.ts
+// src/web.ts
 /**
 * Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.
 *
@@ -29,7 +29,6 @@ function assignUrlWithRedirectParamFromCurrentLocation(url, delayMs) {
 	if (delayMs === void 0) window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));
 	else return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);
 }
-//#endregion
 export { appendRedirectParamFromCurrentLocationToUrl, assignUrlWithRedirectParamFromCurrentLocation };
 
 //# sourceMappingURL=web.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kikiutils/shared",
   "type": "module",
-  "version": "18.3.0",
+  "version": "19.0.0",
   "description": "A lightweight and modular utility library for modern JavaScript and TypeScript — includes secure hashing, flexible logging, datetime tools, Vue/web helpers, storage abstraction, and more.",
   "author": "kiki-kanri",
   "license": "MIT",
@@ -27,12 +27,60 @@
     "crypto",
     "hashing",
     "storage",
-    "logging",
-    "consola",
-    "pino"
+    "logging"
   ],
   "sideEffects": false,
   "exports": {
+    "./logger": {
+      "types": "./dist/logger/index.d.ts",
+      "import": "./dist/logger/index.js",
+      "require": null
+    },
+    "./logger/_internals/formatter": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./logger/_internals/levels": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./logger/_internals/logger": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./logger/_internals/types": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./logger/index": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./logger/node": {
+      "types": "./dist/logger/node/index.d.ts",
+      "import": "./dist/logger/node/index.js",
+      "require": null
+    },
+    "./logger/node/_internals/file-writer": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./logger/node/_internals/formatter": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
+    "./logger/node/index": {
+      "types": null,
+      "import": null,
+      "require": null
+    },
     "./package.json": "./package.json",
     "./types": {
       "types": "./dist/types/index.d.ts",
@@ -67,40 +115,30 @@
     "typecheck": "tsc -b --noEmit"
   },
   "peerDependencies": {
-    "@noble/hashes": "^2.3.0",
-    "@types/ssh2": "^1.15.5",
+    "@noble/hashes": "^2.4.0",
     "async-validator": "^4.2.5",
-    "bson": "^7.3.2",
-    "consola": "^3.4.2",
+    "bson": "^7.3.3",
     "date-fns": "^4.4.0",
     "decimal.js": "^10.6.0",
-    "element-plus": "^2.14.4",
-    "file-type": "^22.1.1",
-    "lru-cache": "^11.5.2",
+    "element-plus": "^2.14.7",
+    "file-type": "^22.2.0",
+    "lru-cache": "^11.5.3",
     "millify": "^6.1.0",
-    "msgpackr": "^2.0.5",
-    "node-ssh": "^13.2.1",
-    "pino": "^10.3.1",
-    "pino-pretty": "^13.1.3",
-    "vue": "^3.5.41",
+    "msgpackr": "^2.1.0",
+    "rotating-file-stream": "^3.2.10",
+    "vue": "^3.5.44",
     "vue-router": ">= 4.6.4"
   },
   "peerDependenciesMeta": {
     "@noble/hashes": {
       "optional": true
     },
-    "@types/ssh2": {
-      "optional": true
-    },
     "async-validator": {
       "optional": true
     },
     "bson": {
       "optional": true
     },
-    "consola": {
-      "optional": true
-    },
     "date-fns": {
       "optional": true
     },
@@ -122,13 +160,7 @@
     "msgpackr": {
       "optional": true
     },
-    "node-ssh": {
-      "optional": true
-    },
-    "pino": {
-      "optional": true
-    },
-    "pino-pretty": {
+    "rotating-file-stream": {
       "optional": true
     },
     "vue": {
@@ -139,37 +171,33 @@
     }
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^9.5.1",
-    "@kikiutils/eslint-config": "^9.3.0",
+    "@antfu/eslint-config": "^10.0.0",
+    "@kikiutils/eslint-config": "^9.3.1",
     "@kikiutils/tsconfigs": "^7.0.0",
     "@noble/hashes": "^2.4.0",
     "@types/node": "^26.6.5",
-    "@types/ssh2": "^1.15.6",
-    "@vitest/coverage-v8": "^5.0.4",
+    "@vitest/coverage-v8": "^5.0.5",
     "async-validator": "^4.2.5",
     "bson": "^7.3.3",
     "changelogen": "^0.6.2",
-    "consola": "^3.4.2",
     "cross-env": "^10.1.0",
     "date-fns": "^4.4.0",
     "decimal.js": "^10.6.0",
     "element-plus": "^2.14.7",
-    "eslint": "^10.12.0",
-    "file-type": "^22.1.1",
-    "jsdom": "^30.1.2",
-    "knip": "^6.41.0",
+    "eslint": "^10.13.0",
+    "file-type": "^22.2.0",
+    "jsdom": "^30.1.3",
+    "knip": "^6.42.1",
     "lru-cache": "^11.5.3",
     "millify": "^6.1.0",
-    "msgpackr": "^2.1.0",
-    "node-ssh": "^13.2.1",
-    "pino": "^10.4.0",
-    "pino-pretty": "^13.2.0",
+    "msgpackr": "^2.1.2",
     "publint": "^0.3.25",
-    "tsdown": "^0.23.1",
+    "rotating-file-stream": "^3.2.10",
+    "tsdown": "^0.23.2",
     "typescript": "^6.0.3",
     "unplugin-unused": "^0.6.0",
-    "vitest": "^5.0.4",
-    "vue": "^3.5.43",
+    "vitest": "^5.0.5",
+    "vue": "^3.5.44",
     "vue-router": "^5.4.0"
   }
 }

package/src/logger/_internals/formatter.ts

@@ -0,0 +1,80 @@
+import {
+    getLoggerStreamName,
+    loggerMethods,
+} from './levels';
+import type { LoggerRecord } from './types';
+
+// Functions
+
+/** Native console formatting keeps user strings literal and objects expandable. */
+export function formatLoggerConsoleArgs(record: LoggerRecord): unknown[] {
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        const target = process[getLoggerStreamName(record.type)];
+        const parts = formatLoggerParts(record, supportsLoggerColor(target));
+        return [
+            parts.map((part) => typeof part === 'string' ? '%s' : '%O').join(' '),
+            ...parts,
+        ];
+    }
+
+    const format: string[] = [];
+    const args: unknown[] = [];
+    const decorate = (text: string, color: string) => {
+        format.push('%c%s%c');
+        args.push(`color: ${color}`, text, '');
+    };
+
+    if (record.icons) decorate(loggerMethods[record.type].icon, loggerMethods[record.type].cssColor);
+    if (record.timestamp) decorate(formatLoggerTime(record.date), '#808080');
+    if (record.prefix) decorate(record.prefix, '#0891b2');
+    for (const arg of record.args) {
+        format.push(typeof arg === 'string' ? '%s' : '%o');
+        args.push(arg);
+    }
+
+    if (record.suffix) decorate(record.suffix, '#0891b2');
+    return [
+        format.join(' '),
+        ...args,
+    ];
+}
+
+/** Keeps data arguments intact so browser developer tools can expand objects. */
+export function formatLoggerParts(record: LoggerRecord, colors = false): unknown[] {
+    const parts: unknown[] = [];
+    const paint = (text: string, color: string) => colors ? `\u001B[${color}m${text}\u001B[0m` : text;
+    if (record.icons) parts.push(paint(loggerMethods[record.type].icon, loggerMethods[record.type].ansiColor));
+    if (record.timestamp) parts.push(paint(formatLoggerTime(record.date), '90'));
+    if (record.prefix) parts.push(paint(record.prefix, '36'));
+    parts.push(...record.args);
+    if (record.suffix) parts.push(paint(record.suffix, '36'));
+    return parts;
+}
+
+/** Fixed local-time representation, deliberately without a per-second cache. */
+export function formatLoggerTime(date: Date): string {
+    const pad = (value: number, width = 2) => String(value).padStart(width, '0');
+    const day = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+    const time = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+    return `[${day} ${time}.${pad(date.getMilliseconds(), 3)}]`;
+}
+
+/** Use native terminal detection; redirected streams still honor FORCE_COLOR. */
+export function supportsLoggerColor(target: { hasColors?: () => boolean; isTTY?: boolean }): boolean {
+    if (target.hasColors) return target.hasColors();
+    const forced = process.env.FORCE_COLOR;
+    if (forced !== undefined) {
+        return [
+            '',
+            '1',
+            '2',
+            '3',
+            'true',
+        ].includes(forced);
+    }
+
+    return Boolean(target.isTTY)
+      && !process.env.NO_COLOR
+      && !process.env.NODE_DISABLE_COLORS
+      && process.env.TERM !== 'dumb';
+}

package/src/logger/_internals/levels.ts

@@ -0,0 +1,60 @@
+import type { LoggerMethod } from '../types';
+
+// Constants/Variables
+export const loggerMethods = {
+    debug: {
+        ansiColor: '36',
+        consoleMethod: 'debug',
+        cssColor: '#0891b2',
+        icon: '⚙',
+        severity: 20,
+    },
+    error: {
+        ansiColor: '31',
+        consoleMethod: 'error',
+        cssColor: '#dc2626',
+        icon: '✖',
+        severity: 50,
+    },
+    fatal: {
+        ansiColor: '31',
+        consoleMethod: 'error',
+        cssColor: '#dc2626',
+        icon: '✖',
+        severity: 60,
+    },
+    info: {
+        ansiColor: '36',
+        consoleMethod: 'info',
+        cssColor: '#0891b2',
+        icon: 'ℹ',
+        severity: 30,
+    },
+    success: {
+        ansiColor: '32',
+        consoleMethod: 'info',
+        cssColor: '#16a34a',
+        icon: '✔',
+        severity: 30,
+    },
+    trace: {
+        ansiColor: '90',
+        consoleMethod: 'debug',
+        cssColor: '#808080',
+        icon: '·',
+        severity: 10,
+    },
+    warn: {
+        ansiColor: '33',
+        consoleMethod: 'warn',
+        cssColor: '#ca8a04',
+        icon: '⚠',
+        severity: 40,
+    },
+} as const;
+
+// Functions
+export function getLoggerStreamName(type: LoggerMethod): 'stderr' | 'stdout' {
+    const method = loggerMethods[type].consoleMethod;
+    return method === 'warn' || method === 'error' ? 'stderr' : 'stdout';
+}

package/src/logger/_internals/logger.ts

@@ -0,0 +1,224 @@
+import type {
+    Logger,
+    LoggerDiagnostic,
+    LoggerLevel,
+    LoggerMethod,
+    LoggerOptions,
+} from '../types';
+
+import { loggerMethods } from './levels';
+import type { LoggerRecord } from './types';
+
+interface LoggerHooks {
+    /** A non-throwing reporter created by createDiagnosticReporter. */
+    report: (event: LoggerDiagnostic) => void;
+    write: (record: LoggerRecord) => Promise<void> | void;
+}
+
+// Constants/Variables
+const booleanPresentationKeys = [
+    'console',
+    'icons',
+    'timestamp',
+] as const;
+
+const stringPresentationKeys = [
+    'prefix',
+    'suffix',
+] as const;
+
+// Functions
+
+/** A non-recursive, rate-limited diagnostic boundary shared by server and browser adapters. */
+export function createDiagnosticReporter(
+    onError?: (event: LoggerDiagnostic) => void,
+    fallback?: (message: string) => void,
+): (event: LoggerDiagnostic) => void {
+    let reporting = false;
+    let callbackPending = false;
+    const stateByType = new Map<LoggerDiagnostic['type'], { lastReportedAt: number; suppressedCount: number }>();
+
+    return (event) => {
+        if (reporting) return;
+        try {
+            const now = Date.now();
+            const state = stateByType.get(event.type);
+            if (state && now - state.lastReportedAt < 1000) {
+                state.suppressedCount++;
+                return;
+            }
+
+            reporting = true;
+            const suppressedCount = state?.suppressedCount ?? 0;
+            if (suppressedCount) {
+                event = {
+                    ...event,
+                    suppressedCount,
+                };
+            }
+
+            stateByType.set(
+                event.type,
+                {
+                    lastReportedAt: now,
+                    suppressedCount: 0,
+                },
+            );
+
+            try {
+                const summary = suppressedCount ? ` (${suppressedCount} similar diagnostics suppressed)` : '';
+                fallback?.(`[logger] ${event.message}${summary}\n`);
+            } catch {
+                // Diagnostics must never re-enter the normal logging pipeline.
+            }
+
+            if (!callbackPending) {
+                try {
+                    callbackPending = true;
+                    const result: unknown = onError?.(event);
+                    if (result !== null && (typeof result === 'object' || typeof result === 'function')) {
+                        void Promise.resolve(result).then(
+                            () => {
+                                callbackPending = false;
+                            },
+                            () => {
+                                callbackPending = false;
+                            },
+                        );
+                    } else {
+                        callbackPending = false;
+                    }
+                } catch {
+                    callbackPending = false;
+                    // User diagnostic callbacks have the same non-throwing boundary.
+                }
+            }
+        } catch { /* Diagnostics must never escape into the logging pipeline. */ } finally {
+            reporting = false;
+        }
+    };
+}
+
+export function createLoggerCore(options: LoggerOptions, hooks: LoggerHooks): Logger {
+    validateLevel(options.level);
+    validatePresentation(options);
+    if (options.onError !== undefined && typeof options.onError !== 'function') {
+        throw new TypeError('Logger onError must be a function');
+    }
+
+    const presentation = {
+        console: options.console ?? true,
+        icons: options.icons ?? true,
+        prefix: options.prefix ?? '',
+        suffix: options.suffix ?? '',
+        timestamp: options.timestamp ?? true,
+    };
+
+    const { report } = hooks;
+
+    let override = options.level === 'env' ? undefined : options.level;
+    let previousEnvironment: string | undefined;
+    let currentLevel: LoggerLevel = override ?? 'info';
+    let environmentRead = false;
+
+    function refreshLevel() {
+        if (override !== undefined) return;
+        const input = readEnvironmentLevel();
+        if (environmentRead && input === previousEnvironment) return;
+        environmentRead = true;
+        previousEnvironment = input;
+        const normalized = input?.trim().toLowerCase() || undefined;
+        currentLevel = isLevel(normalized) ? normalized : 'info';
+        if (normalized !== undefined && !isLevel(normalized)) {
+            report({
+                message: 'Invalid LOG_LEVEL; using info',
+                type: 'invalid-level',
+            });
+        }
+    }
+
+    const logger = {
+        configure(configuration) {
+            validatePresentation(configuration);
+            for (const name of booleanPresentationKeys) {
+                const value = configuration[name];
+                if (value !== undefined) presentation[name] = value;
+            }
+
+            for (const name of stringPresentationKeys) {
+                const value = configuration[name];
+                if (value !== undefined) presentation[name] = value;
+            }
+        },
+        isLevelEnabled(level) {
+            if (level !== 'success' && !isLevel(level)) throw new TypeError('Invalid logger level');
+            refreshLevel();
+            return level !== 'silent' && getLevelSeverity(level) >= getLevelSeverity(currentLevel);
+        },
+        setLevel(level) {
+            validateLevel(level);
+            if (level === undefined) throw new TypeError('Invalid logger level');
+            override = level === 'env' ? undefined : level;
+            environmentRead = false;
+            if (override !== undefined) {
+                currentLevel = override;
+            } else {
+                refreshLevel();
+            }
+        },
+    } as Logger;
+
+    for (const type of Object.keys(loggerMethods) as LoggerMethod[]) {
+        logger[type] = async (...args: unknown[]) => {
+            try {
+                refreshLevel();
+                if (loggerMethods[type].severity < getLevelSeverity(currentLevel)) return;
+                await hooks.write({
+                    ...presentation,
+                    args,
+                    date: new Date(),
+                    type,
+                });
+            } catch (error) {
+                report({
+                    error,
+                    message: 'Logger output failed',
+                    type: 'format',
+                });
+            }
+        };
+    }
+
+    return logger;
+}
+
+function getLevelSeverity(level: LoggerLevel | LoggerMethod): number {
+    return level === 'silent' ? Number.POSITIVE_INFINITY : loggerMethods[level].severity;
+}
+
+function isLevel(value: unknown): value is LoggerLevel {
+    return typeof value === 'string'
+      && (value === 'silent' || (value !== 'success' && Object.hasOwn(loggerMethods, value)));
+}
+
+function readEnvironmentLevel(): string | undefined {
+    return (globalThis as { process?: { env?: { LOG_LEVEL?: string } } }).process?.env?.LOG_LEVEL;
+}
+
+function validateLevel(value: unknown): asserts value is 'env' | LoggerLevel | undefined {
+    if (value !== undefined && value !== 'env' && !isLevel(value)) throw new TypeError('Invalid logger level');
+}
+
+function validatePresentation(options: Pick<LoggerOptions, 'console' | 'icons' | 'prefix' | 'suffix' | 'timestamp'>) {
+    for (const name of booleanPresentationKeys) {
+        if (options[name] !== undefined && typeof options[name] !== 'boolean') {
+            throw new TypeError(`Logger ${name} must be a boolean`);
+        }
+    }
+
+    for (const name of stringPresentationKeys) {
+        if (options[name] !== undefined && typeof options[name] !== 'string') {
+            throw new TypeError(`Logger ${name} must be a string`);
+        }
+    }
+}