@geekmidas/logger 0.0.1 → 0.2.0

package/README.md

@@ -4,13 +4,12 @@ A simple and flexible structured logging library for Node.js and browsers with c
 
 ## Features
 
-- ✅ **Standard Interface**: Common logger interface with multiple log levels (debug, info, warn, error, fatal, trace)
-- ✅ **Structured Logging**: Support for both structured (object + message) and simple (message only) logging
-- ✅ **Child Loggers**: Create child loggers with inherited context
-- ✅ **Automatic Timestamps**: Automatic timestamp injection on all log entries
-- ✅ **Console-Based**: Built-in ConsoleLogger implementation using standard console methods
-- ✅ **TypeScript**: Full TypeScript support with type-safe logging
-- ✅ **Zero Dependencies**: No external dependencies
+- **Standard Interface**: Common logger interface with multiple log levels (debug, info, warn, error, fatal, trace)
+- **Structured Logging**: Support for both structured (object + message) and simple (message only) logging
+- **Child Loggers**: Create child loggers with inherited context
+- **Multiple Implementations**: ConsoleLogger for simple use, PinoLogger for production
+- **Sensitive Data Redaction**: Built-in redaction for passwords, tokens, API keys, and more
+- **TypeScript**: Full TypeScript support with type-safe logging
 
 ## Installation
 
@@ -38,6 +37,114 @@ logger.info('Application started');
 logger.error({ error, operation: 'fetchUser' }, 'Failed to fetch user');
 ```
 
+## Pino Logger
+
+For production use, the package provides a Pino-based logger with high performance and built-in redaction support.
+
+```typescript
+import { createLogger } from '@geekmidas/logger/pino';
+
+const logger = createLogger({
+  level: 'info',
+  pretty: true,  // Pretty printing in development
+  redact: true,  // Enable sensitive data redaction
+});
+
+logger.info({ userId: 123 }, 'User logged in');
+```
+
+## Sensitive Data Redaction
+
+The Pino logger includes built-in redaction to automatically mask sensitive data like passwords, tokens, and API keys.
+
+### Enable with Defaults
+
+```typescript
+import { createLogger } from '@geekmidas/logger/pino';
+
+const logger = createLogger({ redact: true });
+
+// Sensitive data is automatically masked
+logger.info({ password: 'secret123', user: 'john' }, 'Login attempt');
+// Output: { password: '[Redacted]', user: 'john' } Login attempt
+
+logger.info({ headers: { authorization: 'Bearer xyz' } }, 'Request');
+// Output: { headers: { authorization: '[Redacted]' } } Request
+```
+
+### Default Redacted Fields
+
+When `redact: true`, the following fields are automatically masked:
+
+- **Authentication**: `password`, `pass`, `passwd`, `secret`, `token`, `accessToken`, `refreshToken`, `apiKey`, `api_key`, `authorization`, `credentials`
+- **Headers**: `headers.authorization`, `headers.cookie`, `headers["x-api-key"]`
+- **Personal Data**: `ssn`, `creditCard`, `cardNumber`, `cvv`, `pin`
+- **Secrets**: `connectionString`, `databaseUrl`
+- **Wildcards**: `*.password`, `*.secret`, `*.token` (catches nested fields)
+
+### Add Custom Paths (Merged with Defaults)
+
+```typescript
+const logger = createLogger({
+  redact: ['user.ssn', 'payment.cardNumber'],
+});
+
+// Both custom paths AND defaults are redacted
+logger.info({ password: 'secret', user: { ssn: '123-45-6789' } }, 'Data');
+// Output: { password: '[Redacted]', user: { ssn: '[Redacted]' } } Data
+```
+
+### Override Defaults
+
+Use `resolution: 'override'` to disable default paths and use only your custom paths:
+
+```typescript
+const logger = createLogger({
+  redact: {
+    paths: ['myCustomSecret'],
+    resolution: 'override',
+  },
+});
+
+// Only 'myCustomSecret' is redacted, defaults are ignored
+logger.info({ password: 'visible', myCustomSecret: 'hidden' }, 'Data');
+// Output: { password: 'visible', myCustomSecret: '[Redacted]' } Data
+```
+
+### Custom Censor and Remove
+
+```typescript
+// Custom censor string
+const logger = createLogger({
+  redact: {
+    paths: ['secret'],
+    censor: '***HIDDEN***',
+  },
+});
+
+// Remove fields entirely instead of masking
+const logger2 = createLogger({
+  redact: {
+    paths: ['temporaryData'],
+    remove: true,
+  },
+});
+```
+
+### Path Syntax
+
+Redaction paths support dot notation and wildcards:
+
+```typescript
+redact: [
+  'password',           // Top-level field
+  'user.password',      // Nested field
+  'users[*].password',  // Array wildcard
+  '*.secret',           // Any object's 'secret' field
+  'headers["x-api-key"]', // Bracket notation for special chars
+]
+```
+
 ## API Reference
 
 ### Logger Interface

package/dist/console.cjs

@@ -1,45 +1,83 @@
+const require_types = require('./types-ag_0Cvbg.cjs');
 
 //#region src/console.ts
+/**
+* Numeric priority for log levels (higher = more severe)
+*/
+const LOG_LEVEL_PRIORITY = {
+	[require_types.LogLevel.Trace]: 10,
+	[require_types.LogLevel.Debug]: 20,
+	[require_types.LogLevel.Info]: 30,
+	[require_types.LogLevel.Warn]: 40,
+	[require_types.LogLevel.Error]: 50,
+	[require_types.LogLevel.Fatal]: 60,
+	[require_types.LogLevel.Silent]: 70
+};
 var ConsoleLogger = class ConsoleLogger {
+	level;
 	/**
 	* Creates a new ConsoleLogger instance.
 	*
 	* @param data - Initial context data to include in all log messages
+	* @param level - Minimum log level to output (default: Info)
 	*/
-	constructor(data = {}) {
+	constructor(data = {}, level = require_types.LogLevel.Info) {
 		this.data = data;
+		this.level = level;
+	}
+	/**
+	* Checks if a log level should be output based on the configured minimum level.
+	*/
+	shouldLog(level) {
+		if (this.level === require_types.LogLevel.Silent) return false;
+		return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
 	}
 	/**
 	* Creates a logging function that merges context data and adds timestamps.
 	*
 	* @param logMethod - The console method to use (e.g., console.log, console.error)
+	* @param level - The log level for this method
 	* @returns A LogFn that handles both structured and simple logging
 	* @private
 	*/
-	createLogFn(logMethod) {
-		return (obj, msg, ...args) => {
+	createLogFn(logMethod, level) {
+		return (objOrMsg, msg, ...args) => {
+			if (!this.shouldLog(level)) return;
 			const ts = Date.now();
-			const mergedData = {
+			if (typeof objOrMsg === "string") {
+				const logData$1 = {
+					...this.data,
+					msg: objOrMsg,
+					ts
+				};
+				logMethod(logData$1, ...args);
+				return;
+			}
+			const logData = msg ? {
+				...this.data,
+				...objOrMsg,
+				msg,
+				ts
+			} : {
 				...this.data,
-				...obj,
+				...objOrMsg,
 				ts
 			};
-			if (msg) logMethod(mergedData, msg, ...args);
-			else logMethod(mergedData, ...args);
+			logMethod(logData, ...args);
 		};
 	}
+	/** Trace level logging function */
+	trace = this.createLogFn(console.trace.bind(console), require_types.LogLevel.Trace);
 	/** Debug level logging function */
-	debug = this.createLogFn(console.debug.bind(console));
+	debug = this.createLogFn(console.debug.bind(console), require_types.LogLevel.Debug);
 	/** Info level logging function */
-	info = this.createLogFn(console.info.bind(console));
+	info = this.createLogFn(console.info.bind(console), require_types.LogLevel.Info);
 	/** Warning level logging function */
-	warn = this.createLogFn(console.warn.bind(console));
+	warn = this.createLogFn(console.warn.bind(console), require_types.LogLevel.Warn);
 	/** Error level logging function */
-	error = this.createLogFn(console.error.bind(console));
+	error = this.createLogFn(console.error.bind(console), require_types.LogLevel.Error);
 	/** Fatal level logging function (uses console.error) */
-	fatal = this.createLogFn(console.error.bind(console));
-	/** Trace level logging function */
-	trace = this.createLogFn(console.trace.bind(console));
+	fatal = this.createLogFn(console.error.bind(console), require_types.LogLevel.Fatal);
 	/**
 	* Creates a child logger with additional context data.
 	* The child logger inherits all context from the parent and adds its own.
@@ -59,7 +97,7 @@ var ConsoleLogger = class ConsoleLogger {
 		return new ConsoleLogger({
 			...this.data,
 			...obj
-		});
+		}, this.level);
 	}
 };
 /**
@@ -67,14 +105,14 @@ var ConsoleLogger = class ConsoleLogger {
 * ```typescript
 * const logger = new ConsoleLogger({ app: 'myApp' });
 * logger.info({ action: 'start' }, 'Application starting');
-* // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+* // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
 * ```
 *
 * @example Child logger usage
 * ```typescript
 * const childLogger = logger.child({ module: 'auth' });
 * childLogger.debug({ userId: 123 }, 'User authenticated');
-* // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+* // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
 * ```
 *
 * @example Error logging with context
@@ -87,8 +125,28 @@ var ConsoleLogger = class ConsoleLogger {
 * ```
 */
 const DEFAULT_LOGGER = new ConsoleLogger();
+/**
+* Creates a console logger with the same API as pino's createLogger.
+*
+* @param options - Logger configuration options
+* @returns A ConsoleLogger instance
+*
+* @example
+* ```typescript
+* import { createLogger } from '@geekmidas/logger/console';
+* import { LogLevel } from '@geekmidas/logger';
+*
+* const logger = createLogger({ level: LogLevel.Debug });
+* logger.debug('This will be logged');
+* logger.trace('This will NOT be logged (below Debug level)');
+* ```
+*/
+function createLogger(options = {}) {
+	return new ConsoleLogger({}, options.level ?? require_types.LogLevel.Info);
+}
 
 //#endregion
 exports.ConsoleLogger = ConsoleLogger;
 exports.DEFAULT_LOGGER = DEFAULT_LOGGER;
+exports.createLogger = createLogger;
 //# sourceMappingURL=console.cjs.map

package/dist/console.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"console.cjs","names":["data: object","logMethod: (...args: any[]) => void","obj: T","msg?: string","obj: object"],"sources":["../src/console.ts"],"sourcesContent":["import type { LogFn, Logger } from './types';\n\nexport class ConsoleLogger implements Logger {\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   */\n  constructor(readonly data: object = {}) {}\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(logMethod: (...args: any[]) => void): LogFn {\n    return <T extends object>(obj: T, msg?: string, ...args: any[]): void => {\n      // Merge the logger's context data with the provided object\n      const ts = Date.now();\n      const mergedData = { ...this.data, ...obj, ts };\n\n      if (msg) {\n        logMethod(mergedData, msg, ...args);\n      } else {\n        logMethod(mergedData, ...args);\n      }\n    };\n  }\n\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console));\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console));\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console));\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console));\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console));\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console));\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger({\n      ...this.data,\n      ...obj,\n    });\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n"],"mappings":";;AAEA,IAAa,gBAAb,MAAa,cAAgC;;;;;;CAM3C,YAAqBA,OAAe,CAAE,GAAE;EAAnB;CAAqB;;;;;;;;CAS1C,AAAQ,YAAYC,WAA4C;AAC9D,SAAO,CAAmBC,KAAQC,KAAc,GAAG,SAAsB;GAEvE,MAAM,KAAK,KAAK,KAAK;GACrB,MAAM,aAAa;IAAE,GAAG,KAAK;IAAM,GAAG;IAAK;GAAI;AAE/C,OAAI,IACF,WAAU,YAAY,KAAK,GAAG,KAAK;OAEnC,WAAU,YAAY,GAAG,KAAK;EAEjC;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;;;;;;;;;;;;;;;CAiB5D,MAAMC,KAAqB;AACzB,SAAO,IAAI,cAAc;GACvB,GAAG,KAAK;GACR,GAAG;EACJ;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI"}
+{"version":3,"file":"console.cjs","names":["LOG_LEVEL_PRIORITY: Record<LogLevel, number>","LogLevel","data: object","level: LogLevel","logMethod: (...args: any[]) => void","objOrMsg: T | string","msg?: string","logData","obj: object","options: CreateLoggerOptions"],"sources":["../src/console.ts"],"sourcesContent":["import type { CreateLoggerOptions, LogFn, Logger } from './types';\nimport { LogLevel } from './types';\n\n/**\n * Numeric priority for log levels (higher = more severe)\n */\nconst LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  [LogLevel.Trace]: 10,\n  [LogLevel.Debug]: 20,\n  [LogLevel.Info]: 30,\n  [LogLevel.Warn]: 40,\n  [LogLevel.Error]: 50,\n  [LogLevel.Fatal]: 60,\n  [LogLevel.Silent]: 70,\n};\n\nexport class ConsoleLogger implements Logger {\n  private readonly level: LogLevel;\n\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   * @param level - Minimum log level to output (default: Info)\n   */\n  constructor(\n    readonly data: object = {},\n    level: LogLevel = LogLevel.Info,\n  ) {\n    this.level = level;\n  }\n\n  /**\n   * Checks if a log level should be output based on the configured minimum level.\n   */\n  private shouldLog(level: LogLevel): boolean {\n    if (this.level === LogLevel.Silent) {\n      return false;\n    }\n    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];\n  }\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @param level - The log level for this method\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(\n    logMethod: (...args: any[]) => void,\n    level: LogLevel,\n  ): LogFn {\n    return <T extends object>(\n      objOrMsg: T | string,\n      msg?: string,\n      ...args: any[]\n    ): void => {\n      if (!this.shouldLog(level)) {\n        return;\n      }\n\n      const ts = Date.now();\n\n      // Handle simple string logging: logger.info('message')\n      if (typeof objOrMsg === 'string') {\n        const logData = { ...this.data, msg: objOrMsg, ts };\n        logMethod(logData, ...args);\n        return;\n      }\n\n      // Handle structured logging: logger.info({ data }, 'message')\n      const logData = msg\n        ? { ...this.data, ...objOrMsg, msg, ts }\n        : { ...this.data, ...objOrMsg, ts };\n      logMethod(logData, ...args);\n    };\n  }\n\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console), LogLevel.Trace);\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console), LogLevel.Debug);\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console), LogLevel.Info);\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Error);\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Fatal);\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger(\n      {\n        ...this.data,\n        ...obj,\n      },\n      this.level,\n    );\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n\n/**\n * Creates a console logger with the same API as pino's createLogger.\n *\n * @param options - Logger configuration options\n * @returns A ConsoleLogger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@geekmidas/logger/console';\n * import { LogLevel } from '@geekmidas/logger';\n *\n * const logger = createLogger({ level: LogLevel.Debug });\n * logger.debug('This will be logged');\n * logger.trace('This will NOT be logged (below Debug level)');\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}): Logger {\n  return new ConsoleLogger({}, options.level ?? LogLevel.Info);\n}\n"],"mappings":";;;;;;AAMA,MAAMA,qBAA+C;EAClDC,uBAAS,QAAQ;EACjBA,uBAAS,QAAQ;EACjBA,uBAAS,OAAO;EAChBA,uBAAS,OAAO;EAChBA,uBAAS,QAAQ;EACjBA,uBAAS,QAAQ;EACjBA,uBAAS,SAAS;AACpB;AAED,IAAa,gBAAb,MAAa,cAAgC;CAC3C,AAAiB;;;;;;;CAQjB,YACWC,OAAe,CAAE,GAC1BC,QAAkBF,uBAAS,MAC3B;EAFS;AAGT,OAAK,QAAQ;CACd;;;;CAKD,AAAQ,UAAUE,OAA0B;AAC1C,MAAI,KAAK,UAAUF,uBAAS,OAC1B,QAAO;AAET,SAAO,mBAAmB,UAAU,mBAAmB,KAAK;CAC7D;;;;;;;;;CAUD,AAAQ,YACNG,WACAD,OACO;AACP,SAAO,CACLE,UACAC,KACA,GAAG,SACM;AACT,QAAK,KAAK,UAAU,MAAM,CACxB;GAGF,MAAM,KAAK,KAAK,KAAK;AAGrB,cAAW,aAAa,UAAU;IAChC,MAAMC,YAAU;KAAE,GAAG,KAAK;KAAM,KAAK;KAAU;IAAI;AACnD,cAAUA,WAAS,GAAG,KAAK;AAC3B;GACD;GAGD,MAAM,UAAU,MACZ;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;IAAK;GAAI,IACtC;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;GAAI;AACrC,aAAU,SAAS,GAAG,KAAK;EAC5B;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEN,uBAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEA,uBAAS,MAAM;;CAE5E,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAEA,uBAAS,KAAK;;CAEzE,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAEA,uBAAS,KAAK;;CAEzE,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEA,uBAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEA,uBAAS,MAAM;;;;;;;;;;;;;;;;CAiB5E,MAAMO,KAAqB;AACzB,SAAO,IAAI,cACT;GACE,GAAG,KAAK;GACR,GAAG;EACJ,GACD,KAAK;CAER;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI;;;;;;;;;;;;;;;;;AAkBlC,SAAgB,aAAaC,UAA+B,CAAE,GAAU;AACtE,QAAO,IAAI,cAAc,CAAE,GAAE,QAAQ,SAASR,uBAAS;AACxD"}

package/dist/console.d.cts

@@ -1,22 +1,31 @@
-import { LogFn, Logger } from "./types-DXdmn7h5.cjs";
+import { CreateLoggerOptions, LogFn, LogLevel, Logger } from "./types-JxCFymH0.cjs";
 
 //#region src/console.d.ts
 declare class ConsoleLogger implements Logger {
   readonly data: object;
+  private readonly level;
   /**
    * Creates a new ConsoleLogger instance.
    *
    * @param data - Initial context data to include in all log messages
+   * @param level - Minimum log level to output (default: Info)
    */
-  constructor(data?: object);
+  constructor(data?: object, level?: LogLevel);
+  /**
+   * Checks if a log level should be output based on the configured minimum level.
+   */
+  private shouldLog;
   /**
    * Creates a logging function that merges context data and adds timestamps.
    *
    * @param logMethod - The console method to use (e.g., console.log, console.error)
+   * @param level - The log level for this method
    * @returns A LogFn that handles both structured and simple logging
    * @private
    */
   private createLogFn;
+  /** Trace level logging function */
+  trace: LogFn;
   /** Debug level logging function */
   debug: LogFn;
   /** Info level logging function */
@@ -27,8 +36,6 @@ declare class ConsoleLogger implements Logger {
   error: LogFn;
   /** Fatal level logging function (uses console.error) */
   fatal: LogFn;
-  /** Trace level logging function */
-  trace: LogFn;
   /**
    * Creates a child logger with additional context data.
    * The child logger inherits all context from the parent and adds its own.
@@ -51,14 +58,14 @@ declare class ConsoleLogger implements Logger {
  * ```typescript
  * const logger = new ConsoleLogger({ app: 'myApp' });
  * logger.info({ action: 'start' }, 'Application starting');
- * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+ * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
  * ```
  *
  * @example Child logger usage
  * ```typescript
  * const childLogger = logger.child({ module: 'auth' });
  * childLogger.debug({ userId: 123 }, 'User authenticated');
- * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+ * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
  * ```
  *
  * @example Error logging with context
@@ -71,6 +78,23 @@ declare class ConsoleLogger implements Logger {
  * ```
  */
 declare const DEFAULT_LOGGER: any;
+/**
+ * Creates a console logger with the same API as pino's createLogger.
+ *
+ * @param options - Logger configuration options
+ * @returns A ConsoleLogger instance
+ *
+ * @example
+ * ```typescript
+ * import { createLogger } from '@geekmidas/logger/console';
+ * import { LogLevel } from '@geekmidas/logger';
+ *
+ * const logger = createLogger({ level: LogLevel.Debug });
+ * logger.debug('This will be logged');
+ * logger.trace('This will NOT be logged (below Debug level)');
+ * ```
+ */
+declare function createLogger(options?: CreateLoggerOptions): Logger;
 //#endregion
-export { ConsoleLogger, DEFAULT_LOGGER };
+export { ConsoleLogger, DEFAULT_LOGGER, createLogger };
 //# sourceMappingURL=console.d.cts.map

package/dist/console.d.mts

@@ -1,22 +1,31 @@
-import { LogFn, Logger } from "./types-C1RfRbo6.mjs";
+import { CreateLoggerOptions, LogFn, LogLevel, Logger } from "./types-Bga8WDuP.mjs";
 
 //#region src/console.d.ts
 declare class ConsoleLogger implements Logger {
   readonly data: object;
+  private readonly level;
   /**
    * Creates a new ConsoleLogger instance.
    *
    * @param data - Initial context data to include in all log messages
+   * @param level - Minimum log level to output (default: Info)
    */
-  constructor(data?: object);
+  constructor(data?: object, level?: LogLevel);
+  /**
+   * Checks if a log level should be output based on the configured minimum level.
+   */
+  private shouldLog;
   /**
    * Creates a logging function that merges context data and adds timestamps.
    *
    * @param logMethod - The console method to use (e.g., console.log, console.error)
+   * @param level - The log level for this method
    * @returns A LogFn that handles both structured and simple logging
    * @private
    */
   private createLogFn;
+  /** Trace level logging function */
+  trace: LogFn;
   /** Debug level logging function */
   debug: LogFn;
   /** Info level logging function */
@@ -27,8 +36,6 @@ declare class ConsoleLogger implements Logger {
   error: LogFn;
   /** Fatal level logging function (uses console.error) */
   fatal: LogFn;
-  /** Trace level logging function */
-  trace: LogFn;
   /**
    * Creates a child logger with additional context data.
    * The child logger inherits all context from the parent and adds its own.
@@ -51,14 +58,14 @@ declare class ConsoleLogger implements Logger {
  * ```typescript
  * const logger = new ConsoleLogger({ app: 'myApp' });
  * logger.info({ action: 'start' }, 'Application starting');
- * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+ * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
  * ```
  *
  * @example Child logger usage
  * ```typescript
  * const childLogger = logger.child({ module: 'auth' });
  * childLogger.debug({ userId: 123 }, 'User authenticated');
- * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+ * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
  * ```
  *
  * @example Error logging with context
@@ -71,6 +78,23 @@ declare class ConsoleLogger implements Logger {
  * ```
  */
 declare const DEFAULT_LOGGER: any;
+/**
+ * Creates a console logger with the same API as pino's createLogger.
+ *
+ * @param options - Logger configuration options
+ * @returns A ConsoleLogger instance
+ *
+ * @example
+ * ```typescript
+ * import { createLogger } from '@geekmidas/logger/console';
+ * import { LogLevel } from '@geekmidas/logger';
+ *
+ * const logger = createLogger({ level: LogLevel.Debug });
+ * logger.debug('This will be logged');
+ * logger.trace('This will NOT be logged (below Debug level)');
+ * ```
+ */
+declare function createLogger(options?: CreateLoggerOptions): Logger;
 //#endregion
-export { ConsoleLogger, DEFAULT_LOGGER };
+export { ConsoleLogger, DEFAULT_LOGGER, createLogger };
 //# sourceMappingURL=console.d.mts.map

package/dist/console.mjs

@@ -1,44 +1,83 @@
+import { LogLevel } from "./types-yQ6XOihF.mjs";
+
 //#region src/console.ts
+/**
+* Numeric priority for log levels (higher = more severe)
+*/
+const LOG_LEVEL_PRIORITY = {
+	[LogLevel.Trace]: 10,
+	[LogLevel.Debug]: 20,
+	[LogLevel.Info]: 30,
+	[LogLevel.Warn]: 40,
+	[LogLevel.Error]: 50,
+	[LogLevel.Fatal]: 60,
+	[LogLevel.Silent]: 70
+};
 var ConsoleLogger = class ConsoleLogger {
+	level;
 	/**
 	* Creates a new ConsoleLogger instance.
 	*
 	* @param data - Initial context data to include in all log messages
+	* @param level - Minimum log level to output (default: Info)
 	*/
-	constructor(data = {}) {
+	constructor(data = {}, level = LogLevel.Info) {
 		this.data = data;
+		this.level = level;
+	}
+	/**
+	* Checks if a log level should be output based on the configured minimum level.
+	*/
+	shouldLog(level) {
+		if (this.level === LogLevel.Silent) return false;
+		return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
 	}
 	/**
 	* Creates a logging function that merges context data and adds timestamps.
 	*
 	* @param logMethod - The console method to use (e.g., console.log, console.error)
+	* @param level - The log level for this method
 	* @returns A LogFn that handles both structured and simple logging
 	* @private
 	*/
-	createLogFn(logMethod) {
-		return (obj, msg, ...args) => {
+	createLogFn(logMethod, level) {
+		return (objOrMsg, msg, ...args) => {
+			if (!this.shouldLog(level)) return;
 			const ts = Date.now();
-			const mergedData = {
+			if (typeof objOrMsg === "string") {
+				const logData$1 = {
+					...this.data,
+					msg: objOrMsg,
+					ts
+				};
+				logMethod(logData$1, ...args);
+				return;
+			}
+			const logData = msg ? {
+				...this.data,
+				...objOrMsg,
+				msg,
+				ts
+			} : {
 				...this.data,
-				...obj,
+				...objOrMsg,
 				ts
 			};
-			if (msg) logMethod(mergedData, msg, ...args);
-			else logMethod(mergedData, ...args);
+			logMethod(logData, ...args);
 		};
 	}
+	/** Trace level logging function */
+	trace = this.createLogFn(console.trace.bind(console), LogLevel.Trace);
 	/** Debug level logging function */
-	debug = this.createLogFn(console.debug.bind(console));
+	debug = this.createLogFn(console.debug.bind(console), LogLevel.Debug);
 	/** Info level logging function */
-	info = this.createLogFn(console.info.bind(console));
+	info = this.createLogFn(console.info.bind(console), LogLevel.Info);
 	/** Warning level logging function */
-	warn = this.createLogFn(console.warn.bind(console));
+	warn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);
 	/** Error level logging function */
-	error = this.createLogFn(console.error.bind(console));
+	error = this.createLogFn(console.error.bind(console), LogLevel.Error);
 	/** Fatal level logging function (uses console.error) */
-	fatal = this.createLogFn(console.error.bind(console));
-	/** Trace level logging function */
-	trace = this.createLogFn(console.trace.bind(console));
+	fatal = this.createLogFn(console.error.bind(console), LogLevel.Fatal);
 	/**
 	* Creates a child logger with additional context data.
 	* The child logger inherits all context from the parent and adds its own.
@@ -58,7 +97,7 @@ var ConsoleLogger = class ConsoleLogger {
 		return new ConsoleLogger({
 			...this.data,
 			...obj
-		});
+		}, this.level);
 	}
 };
 /**
@@ -66,14 +105,14 @@ var ConsoleLogger = class ConsoleLogger {
 * ```typescript
 * const logger = new ConsoleLogger({ app: 'myApp' });
 * logger.info({ action: 'start' }, 'Application starting');
-* // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+* // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
 * ```
 *
 * @example Child logger usage
 * ```typescript
 * const childLogger = logger.child({ module: 'auth' });
 * childLogger.debug({ userId: 123 }, 'User authenticated');
-* // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+* // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
 * ```
 *
 * @example Error logging with context
@@ -86,7 +125,26 @@ var ConsoleLogger = class ConsoleLogger {
 * ```
 */
 const DEFAULT_LOGGER = new ConsoleLogger();
+/**
+* Creates a console logger with the same API as pino's createLogger.
+*
+* @param options - Logger configuration options
+* @returns A ConsoleLogger instance
+*
+* @example
+* ```typescript
+* import { createLogger } from '@geekmidas/logger/console';
+* import { LogLevel } from '@geekmidas/logger';
+*
+* const logger = createLogger({ level: LogLevel.Debug });
+* logger.debug('This will be logged');
+* logger.trace('This will NOT be logged (below Debug level)');
+* ```
+*/
+function createLogger(options = {}) {
+	return new ConsoleLogger({}, options.level ?? LogLevel.Info);
+}
 
 //#endregion
-export { ConsoleLogger, DEFAULT_LOGGER };
+export { ConsoleLogger, DEFAULT_LOGGER, createLogger };
 //# sourceMappingURL=console.mjs.map

package/dist/console.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"console.mjs","names":["data: object","logMethod: (...args: any[]) => void","obj: T","msg?: string","obj: object"],"sources":["../src/console.ts"],"sourcesContent":["import type { LogFn, Logger } from './types';\n\nexport class ConsoleLogger implements Logger {\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   */\n  constructor(readonly data: object = {}) {}\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(logMethod: (...args: any[]) => void): LogFn {\n    return <T extends object>(obj: T, msg?: string, ...args: any[]): void => {\n      // Merge the logger's context data with the provided object\n      const ts = Date.now();\n      const mergedData = { ...this.data, ...obj, ts };\n\n      if (msg) {\n        logMethod(mergedData, msg, ...args);\n      } else {\n        logMethod(mergedData, ...args);\n      }\n    };\n  }\n\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console));\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console));\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console));\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console));\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console));\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console));\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger({\n      ...this.data,\n      ...obj,\n    });\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n"],"mappings":";AAEA,IAAa,gBAAb,MAAa,cAAgC;;;;;;CAM3C,YAAqBA,OAAe,CAAE,GAAE;EAAnB;CAAqB;;;;;;;;CAS1C,AAAQ,YAAYC,WAA4C;AAC9D,SAAO,CAAmBC,KAAQC,KAAc,GAAG,SAAsB;GAEvE,MAAM,KAAK,KAAK,KAAK;GACrB,MAAM,aAAa;IAAE,GAAG,KAAK;IAAM,GAAG;IAAK;GAAI;AAE/C,OAAI,IACF,WAAU,YAAY,KAAK,GAAG,KAAK;OAEnC,WAAU,YAAY,GAAG,KAAK;EAEjC;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;;;;;;;;;;;;;;;CAiB5D,MAAMC,KAAqB;AACzB,SAAO,IAAI,cAAc;GACvB,GAAG,KAAK;GACR,GAAG;EACJ;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI"}
+{"version":3,"file":"console.mjs","names":["LOG_LEVEL_PRIORITY: Record<LogLevel, number>","data: object","level: LogLevel","logMethod: (...args: any[]) => void","objOrMsg: T | string","msg?: string","logData","obj: object","options: CreateLoggerOptions"],"sources":["../src/console.ts"],"sourcesContent":["import type { CreateLoggerOptions, LogFn, Logger } from './types';\nimport { LogLevel } from './types';\n\n/**\n * Numeric priority for log levels (higher = more severe)\n */\nconst LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  [LogLevel.Trace]: 10,\n  [LogLevel.Debug]: 20,\n  [LogLevel.Info]: 30,\n  [LogLevel.Warn]: 40,\n  [LogLevel.Error]: 50,\n  [LogLevel.Fatal]: 60,\n  [LogLevel.Silent]: 70,\n};\n\nexport class ConsoleLogger implements Logger {\n  private readonly level: LogLevel;\n\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   * @param level - Minimum log level to output (default: Info)\n   */\n  constructor(\n    readonly data: object = {},\n    level: LogLevel = LogLevel.Info,\n  ) {\n    this.level = level;\n  }\n\n  /**\n   * Checks if a log level should be output based on the configured minimum level.\n   */\n  private shouldLog(level: LogLevel): boolean {\n    if (this.level === LogLevel.Silent) {\n      return false;\n    }\n    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];\n  }\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @param level - The log level for this method\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(\n    logMethod: (...args: any[]) => void,\n    level: LogLevel,\n  ): LogFn {\n    return <T extends object>(\n      objOrMsg: T | string,\n      msg?: string,\n      ...args: any[]\n    ): void => {\n      if (!this.shouldLog(level)) {\n        return;\n      }\n\n      const ts = Date.now();\n\n      // Handle simple string logging: logger.info('message')\n      if (typeof objOrMsg === 'string') {\n        const logData = { ...this.data, msg: objOrMsg, ts };\n        logMethod(logData, ...args);\n        return;\n      }\n\n      // Handle structured logging: logger.info({ data }, 'message')\n      const logData = msg\n        ? { ...this.data, ...objOrMsg, msg, ts }\n        : { ...this.data, ...objOrMsg, ts };\n      logMethod(logData, ...args);\n    };\n  }\n\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console), LogLevel.Trace);\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console), LogLevel.Debug);\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console), LogLevel.Info);\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Error);\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Fatal);\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger(\n      {\n        ...this.data,\n        ...obj,\n      },\n      this.level,\n    );\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n\n/**\n * Creates a console logger with the same API as pino's createLogger.\n *\n * @param options - Logger configuration options\n * @returns A ConsoleLogger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@geekmidas/logger/console';\n * import { LogLevel } from '@geekmidas/logger';\n *\n * const logger = createLogger({ level: LogLevel.Debug });\n * logger.debug('This will be logged');\n * logger.trace('This will NOT be logged (below Debug level)');\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}): Logger {\n  return new ConsoleLogger({}, options.level ?? LogLevel.Info);\n}\n"],"mappings":";;;;;;AAMA,MAAMA,qBAA+C;EAClD,SAAS,QAAQ;EACjB,SAAS,QAAQ;EACjB,SAAS,OAAO;EAChB,SAAS,OAAO;EAChB,SAAS,QAAQ;EACjB,SAAS,QAAQ;EACjB,SAAS,SAAS;AACpB;AAED,IAAa,gBAAb,MAAa,cAAgC;CAC3C,AAAiB;;;;;;;CAQjB,YACWC,OAAe,CAAE,GAC1BC,QAAkB,SAAS,MAC3B;EAFS;AAGT,OAAK,QAAQ;CACd;;;;CAKD,AAAQ,UAAUA,OAA0B;AAC1C,MAAI,KAAK,UAAU,SAAS,OAC1B,QAAO;AAET,SAAO,mBAAmB,UAAU,mBAAmB,KAAK;CAC7D;;;;;;;;;CAUD,AAAQ,YACNC,WACAD,OACO;AACP,SAAO,CACLE,UACAC,KACA,GAAG,SACM;AACT,QAAK,KAAK,UAAU,MAAM,CACxB;GAGF,MAAM,KAAK,KAAK,KAAK;AAGrB,cAAW,aAAa,UAAU;IAChC,MAAMC,YAAU;KAAE,GAAG,KAAK;KAAM,KAAK;KAAU;IAAI;AACnD,cAAUA,WAAS,GAAG,KAAK;AAC3B;GACD;GAGD,MAAM,UAAU,MACZ;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;IAAK;GAAI,IACtC;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;GAAI;AACrC,aAAU,SAAS,GAAG,KAAK;EAC5B;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;CAE5E,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAE,SAAS,KAAK;;CAEzE,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAE,SAAS,KAAK;;CAEzE,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;;;;;;;;;;;;;;;CAiB5E,MAAMC,KAAqB;AACzB,SAAO,IAAI,cACT;GACE,GAAG,KAAK;GACR,GAAG;EACJ,GACD,KAAK;CAER;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI;;;;;;;;;;;;;;;;;AAkBlC,SAAgB,aAAaC,UAA+B,CAAE,GAAU;AACtE,QAAO,IAAI,cAAc,CAAE,GAAE,QAAQ,SAAS,SAAS;AACxD"}