kayvee 3.17.0 → 4.0.0

package/dist/logger/logger.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+exports.setGlobalRouting = setGlobalRouting;
+exports.getGlobalRouter = getGlobalRouter;
+exports.mockRouting = mockRouting;
+const kv = __importStar(require("../kayvee"));
+const router_1 = require("../router");
+const LEVELS = {
+    Trace: "trace",
+    Debug: "debug",
+    Info: "info",
+    Warning: "warning",
+    Error: "error",
+    Critical: "critical",
+};
+const LOG_LEVEL_ENUM = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warning: 3,
+    error: 4,
+    critical: 5,
+};
+let globalRouter;
+function setGlobalRouting(filename) {
+    globalRouter = new router_1.Router();
+    globalRouter.loadConfig(filename);
+}
+function getGlobalRouter() {
+    return globalRouter;
+}
+class Logger {
+    static Trace = LEVELS.Trace;
+    static Debug = LEVELS.Debug;
+    static Info = LEVELS.Info;
+    static Warning = LEVELS.Warning;
+    static Error = LEVELS.Error;
+    static Critical = LEVELS.Critical;
+    static LEVELS = ["trace", "debug", "info", "warn", "error", "critical"];
+    static METRICS = ["counter", "gauge"];
+    formatter;
+    logLvl;
+    globals;
+    logWriter;
+    logRouter;
+    asyncLocalStorage;
+    constructor(source, logLvl = process.env.KAYVEE_LOG_LEVEL, formatter = kv.format, output = console.error) {
+        this.formatter = formatter;
+        this.logLvl = this._validateLogLvl(logLvl);
+        this.globals = {};
+        this.globals.source = source;
+        this.logWriter = output;
+        this.logRouter = null;
+        this.asyncLocalStorage = null;
+        if (process.env._TEAM_OWNER)
+            this.globals.team = process.env._TEAM_OWNER;
+        if (process.env._DEPLOY_ENV)
+            this.globals.deploy_env = process.env._DEPLOY_ENV;
+        if (process.env._EXECUTION_NAME)
+            this.globals.wf_id = process.env._EXECUTION_NAME;
+        if (process.env._POD_ID)
+            this.globals["pod-id"] = process.env._POD_ID;
+        if (process.env._POD_SHORTNAME)
+            this.globals["pod-shortname"] = process.env._POD_SHORTNAME;
+        if (process.env._POD_REGION)
+            this.globals["pod-region"] = process.env._POD_REGION;
+        if (process.env._POD_ACCOUNT)
+            this.globals["pod-account"] = process.env._POD_ACCOUNT;
+    }
+    setAsyncLocalStorage(asyncLocalStorage) {
+        this.asyncLocalStorage = asyncLocalStorage;
+    }
+    setRouter(r) {
+        this.logRouter = r;
+    }
+    setConfig(source, logLvl, formatter, output) {
+        this.globals.source = source;
+        this.logLvl = this._validateLogLvl(logLvl);
+        this.formatter = formatter;
+        this.logWriter = output;
+        return this.logWriter;
+    }
+    _validateLogLvl(logLvl) {
+        if (logLvl == null)
+            return LEVELS.Debug;
+        for (const value of Object.values(LEVELS)) {
+            if (logLvl.toLowerCase() === value)
+                return value;
+        }
+        return LEVELS.Debug;
+    }
+    setLogLevel(logLvl) {
+        this.logLvl = this._validateLogLvl(logLvl);
+        return this.logLvl;
+    }
+    setFormatter(formatter) {
+        this.formatter = formatter;
+        return this.formatter;
+    }
+    setOutput(output) {
+        this.logWriter = output;
+        return this.logWriter;
+    }
+    trace(title) {
+        this.traceD(title, {});
+    }
+    debug(title) {
+        this.debugD(title, {});
+    }
+    info(title) {
+        this.infoD(title, {});
+    }
+    warn(title) {
+        this.warnD(title, {});
+    }
+    error(title) {
+        this.errorD(title, {});
+    }
+    critical(title) {
+        this.criticalD(title, {});
+    }
+    counter(title) {
+        this.counterD(title, 1, {});
+    }
+    gauge(title, value) {
+        this.gaugeD(title, value, {});
+    }
+    traceD(title, data) {
+        this._logWithLevel(LEVELS.Trace, { title }, data);
+    }
+    debugD(title, data) {
+        this._logWithLevel(LEVELS.Debug, { title }, data);
+    }
+    infoD(title, data) {
+        this._logWithLevel(LEVELS.Info, { title }, data);
+    }
+    warnD(title, data) {
+        this._logWithLevel(LEVELS.Warning, { title }, data);
+    }
+    errorD(title, data) {
+        this._logWithLevel(LEVELS.Error, { title }, data);
+    }
+    criticalD(title, data) {
+        this._logWithLevel(LEVELS.Critical, { title }, data);
+    }
+    counterD(title, value, data) {
+        this._logWithLevel(LEVELS.Info, { title, value, type: "counter" }, data);
+    }
+    gaugeD(title, value, data) {
+        this._logWithLevel(LEVELS.Info, { title, value, type: "gauge" }, data);
+    }
+    _logWithLevel(logLvl, metadata, userdata) {
+        if (LOG_LEVEL_ENUM[logLvl] < LOG_LEVEL_ENUM[this.logLvl])
+            return;
+        const store = this.asyncLocalStorage && this.asyncLocalStorage.getStore();
+        const storeData = store || { get: () => ({}) };
+        const contextData = storeData.get("context") ? storeData.get("context") : {};
+        const plainContextData = contextData instanceof Map ? Object.fromEntries(contextData) : contextData;
+        const data = Object.assign({ level: logLvl }, this.globals, metadata, plainContextData, userdata);
+        if (this.logRouter) {
+            data._kvmeta = this.logRouter.route(data);
+        }
+        else if (globalRouter) {
+            data._kvmeta = globalRouter.route(data);
+        }
+        this.logWriter(this.formatter(data));
+    }
+}
+exports.Logger = Logger;
+function mockRouting(cb) {
+    const _logWithLevel = Logger.prototype._logWithLevel;
+    if (_logWithLevel.isMocked) {
+        throw Error("Nested kv.mockRouting calls are not supported");
+    }
+    const ruleMatches = {};
+    Logger.prototype._logWithLevel = function (logLvl, metadata, userdata) {
+        const formatter = this.formatter;
+        const logWriter = this.logWriter;
+        this.formatter = (msg) => msg;
+        this.logWriter = (msg) => {
+            if (!msg._kvmeta)
+                return;
+            msg._kvmeta.routes.forEach((route) => {
+                ruleMatches[route.rule] = (ruleMatches[route.rule] || []).concat(route);
+            });
+        };
+        _logWithLevel.call(this, logLvl, metadata, userdata);
+        this.formatter = formatter;
+        this.logWriter = logWriter;
+    };
+    Logger.prototype._logWithLevel.isMocked = true;
+    const done = () => {
+        Logger.prototype._logWithLevel = _logWithLevel;
+        return ruleMatches;
+    };
+    cb(done);
+}
+// Expose module-level functions as static members on Logger for backwards compatibility.
+// Tests and consumers that do `const { Logger: KV } = require("kayvee/logger")`
+// can call `KV.setGlobalRouting(...)` and `KV.mockRouting(...)`.
+Logger.setGlobalRouting = setGlobalRouting;
+Logger.getGlobalRouter = getGlobalRouter;
+Logger.mockRouting = mockRouting;

package/dist/middleware.d.ts

@@ -0,0 +1,23 @@
+import type { Request, Response, NextFunction } from "express";
+type Handler = (req: Request, res?: Response) => Record<string, unknown>;
+export declare class ContextLogger {
+    logger: any;
+    handlers: Handler[];
+    req: Request;
+    res?: Response;
+    constructor(logger: any, handlers: Handler[], req: Request, res?: Response);
+    _contextualData(data: Record<string, unknown>): Record<string, unknown>;
+}
+export interface MiddlewareOptions {
+    source: string;
+    headers?: string[];
+    handlers?: Handler[];
+    base_handlers?: Handler[];
+    ignore_dir?: {
+        directory: string;
+        path: string;
+    };
+}
+export declare function middleware(clever_options: MiddlewareOptions, secondOpt?: any): (req: Request, res: Response, next: NextFunction) => void;
+export {};
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../lib/middleware.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAyE/D,KAAK,OAAO,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAoCzE,qBAAa,aAAa;IACxB,MAAM,EAAE,GAAG,CAAC;IACZ,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,CAAC,EAAE,QAAQ,CAAC;gBAEH,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,QAAQ;IAO1E,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGxE;AA2BD,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;IAC1B,UAAU,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAClD;AA0CD,wBAAgB,UAAU,CACxB,cAAc,EAAE,iBAAiB,EACjC,SAAS,CAAC,EAAE,GAAG,GACd,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,KAAK,IAAI,CAkC3D"}

package/dist/middleware.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextLogger = void 0;
+exports.middleware = middleware;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const morgan_1 = __importDefault(require("morgan"));
+const qs_1 = __importDefault(require("qs"));
+const kayvee_1 = require("./kayvee");
+const logger_1 = require("./logger/logger");
+function walkDirSync(dir, files = []) {
+    const list = node_fs_1.default.readdirSync(dir);
+    list.forEach((file) => {
+        const f = node_path_1.default.join(dir, file);
+        if (node_fs_1.default.statSync(node_path_1.default.join(dir, file)).isDirectory()) {
+            walkDirSync(f, files);
+        }
+        else {
+            files.push(f);
+        }
+    });
+    return files.map((f) => node_path_1.default.relative(dir, f));
+}
+function skip_path(dir, base_path = "/") {
+    let files = walkDirSync(dir);
+    files = files.map((file) => node_path_1.default.join(base_path, file));
+    console.error(`KayveeMiddleware: Skipping successful requests for files in ${dir} at ${base_path}`);
+    return (req, res) => files.includes(req.path) && res.statusCode < 400;
+}
+function getBaseUrl(req) {
+    const url = req.originalUrl || req.url;
+    const parsed = (0, node_url_1.parse)(url, true);
+    return parsed.pathname ?? null;
+}
+function getQueryParams(req) {
+    const url = req.originalUrl || req.url;
+    const parsed = (0, node_url_1.parse)(url, true);
+    const parsedQueryString = qs_1.default.parse(parsed.search ?? "", {
+        allowPrototypes: false,
+        ignoreQueryPrefix: true,
+    });
+    return `?${qs_1.default.stringify(parsedQueryString)}`;
+}
+function getResponseSize(res) {
+    const headers = res.getHeaders ? res.getHeaders() : res._headers;
+    if (headers && headers["content-length"]) {
+        return Number(headers["content-length"]);
+    }
+    else if (res.data) {
+        return res.data.length;
+    }
+    return undefined;
+}
+function getResponseTimeNs(req, res) {
+    if (!req._startAt || !res._startAt) {
+        return undefined;
+    }
+    const ns = (res._startAt[0] - req._startAt[0]) * 1e9 +
+        (res._startAt[1] - req._startAt[1]);
+    return ns;
+}
+function getIp(req) {
+    const remoteAddress = req.connection ? req.connection.remoteAddress : undefined;
+    return req.ip || remoteAddress;
+}
+function getLogLevel(req, res) {
+    const statusCode = res.statusCode;
+    if (statusCode >= 499) {
+        return logger_1.Logger.Error;
+    }
+    return logger_1.Logger.Info;
+}
+const defaultHandlers = [
+    (req) => ({ method: req.method }),
+    (req) => ({ path: getBaseUrl(req) }),
+    (req) => ({ params: getQueryParams(req) }),
+    (req, res) => ({ "response-size": getResponseSize(res) }),
+    (req, res) => ({ "response-time": getResponseTimeNs(req, res) }),
+    (req, res) => ({ "status-code": res.statusCode }),
+    (req) => ({ ip: getIp(req) }),
+    () => ({ via: "kayvee-middleware" }),
+    (req, res) => ({ level: getLogLevel(req, res) }),
+    () => ({ title: "request-finished" }),
+];
+const defaultContextHandlers = [];
+function handlerData(handlers, req, res) {
+    const data = {};
+    handlers.forEach((h) => {
+        try {
+            const handler_data = h(req, res);
+            if (handler_data !== null &&
+                typeof handler_data === "object" &&
+                !Array.isArray(handler_data)) {
+                Object.assign(data, handler_data);
+            }
+        }
+        catch (e) {
+            // swallow invalid handler
+        }
+    });
+    return data;
+}
+class ContextLogger {
+    logger;
+    handlers;
+    req;
+    res;
+    constructor(logger, handlers, req, res) {
+        this.logger = logger;
+        this.handlers = handlers;
+        this.req = req;
+        this.res = res;
+    }
+    _contextualData(data) {
+        return Object.assign(handlerData(this.handlers, this.req, this.res), data);
+    }
+}
+exports.ContextLogger = ContextLogger;
+for (const func of logger_1.Logger.LEVELS) {
+    ContextLogger.prototype[func] = function (title) {
+        this[`${func}D`](title, {});
+    };
+    ContextLogger.prototype[`${func}D`] = function (title, data) {
+        this.logger[`${func}D`](title, this._contextualData(data));
+    };
+}
+for (const func of logger_1.Logger.METRICS) {
+    ContextLogger.prototype[func] = function (title, value) {
+        this[`${func}D`](title, value, {});
+    };
+    ContextLogger.prototype[`${func}D`] = function (title, value, data) {
+        this.logger[`${func}D`](title, value, this._contextualData(data));
+    };
+}
+const formatLine = (options_arg) => {
+    const options = options_arg || {};
+    if (!options.source) {
+        throw Error("Missing required config for 'source' in Kayvee middleware 'options'");
+    }
+    const router = (0, logger_1.getGlobalRouter)();
+    return (_tokens, req, res) => {
+        const data = {};
+        const custom_headers = options.headers || [];
+        const header_data = {};
+        custom_headers.forEach((h) => {
+            const lc = h.toLowerCase();
+            header_data[lc] = req.headers[lc];
+        });
+        Object.assign(data, header_data);
+        const custom_handlers = options.handlers || [];
+        let base_handlers = options.base_handlers || defaultHandlers;
+        base_handlers = base_handlers.concat([() => ({ source: options.source })]);
+        const all_handlers = custom_handlers.concat(base_handlers);
+        Object.assign(data, handlerData(all_handlers, req, res));
+        if (router) {
+            data._kvmeta = router.route(data);
+        }
+        return (0, kayvee_1.format)(data);
+    };
+};
+const defaultContextLoggerOpts = {
+    enabled: true,
+    handlers: defaultContextHandlers,
+};
+function middleware(clever_options, secondOpt) {
+    if (process.env.NODE_ENV === "test") {
+        const morgan_options = secondOpt || { skip: null };
+        if (clever_options.ignore_dir) {
+            morgan_options.skip = skip_path(clever_options.ignore_dir.directory, clever_options.ignore_dir.path);
+        }
+        return (0, morgan_1.default)(formatLine(clever_options), morgan_options);
+    }
+    if (!clever_options.source) {
+        throw new Error("Missing required config for 'source' in Kayvee middleware 'options'");
+    }
+    const context_logger_options = secondOpt || defaultContextLoggerOpts;
+    const logger = new logger_1.Logger(clever_options.source);
+    const morgan_options = {
+        stream: process.stderr,
+        skip: null,
+    };
+    if (clever_options.ignore_dir) {
+        morgan_options.skip = skip_path(clever_options.ignore_dir.directory, clever_options.ignore_dir.path);
+    }
+    const morgan_logger = (0, morgan_1.default)(formatLine(clever_options), morgan_options);
+    return (req, res, next) => {
+        if (context_logger_options.enabled) {
+            req.log = new ContextLogger(logger, context_logger_options.handlers, req);
+        }
+        morgan_logger(req, res, next);
+    };
+}

package/dist/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "kayvee",
+  "description": "Write data to key=val pairs, for human and machine readability",
+  "version": "4.0.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import":  "./dist/index.js",
+      "types":   "./dist/index.d.ts"
+    },
+    "./logger": {
+      "require": "./dist/logger/logger.js",
+      "import":  "./dist/logger/logger.js",
+      "types":   "./dist/logger/logger.d.ts"
+    },
+    "./middleware": {
+      "require": "./dist/middleware.js",
+      "import":  "./dist/middleware.js",
+      "types":   "./dist/middleware.d.ts"
+    },
+    "./router": {
+      "require": "./dist/router/index.js",
+      "import":  "./dist/router/index.js",
+      "types":   "./dist/router/index.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "logger": ["dist/logger/logger.d.ts"],
+      "middleware": ["dist/middleware.d.ts"],
+      "router": ["dist/router/index.d.ts"]
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Clever/kayvee-js"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0",
+    "jsonschema": "^1.5.0",
+    "morgan": "^1.10.0",
+    "qs": "^6.13.0"
+  },
+  "devDependencies": {
+    "@clever/prettier-config": "1.0.0",
+    "@types/express": "^4.17.23",
+    "@types/js-yaml": "^4.0.9",
+    "@types/jsonschema": "^1.1.1",
+    "@types/mocha": "^10.0.6",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^20.11.0",
+    "@types/qs": "^6.9.11",
+    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "benchmark": "^2.1.1",
+    "eslint": "^8.56.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-formatter-summary": "^1.1.0",
+    "express": "^4.18.2",
+    "mocha": "^10.2.0",
+    "prettier": "^3.2.5",
+    "sinon": "^17.0.1",
+    "split": "^1.0.0",
+    "supertest": "^6.3.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.0",
+    "underscore": "^1.8.3"
+  },
+  "scripts": {
+    "test": "make -Br test",
+    "prepublishOnly": "make build"
+  },
+  "author": "Clever <tech-notify@clever.com>",
+  "license": "BSD-2-Clause",
+  "bugs": {
+    "url": "https://github.com/Clever/kayvee-js/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  }
+}

package/dist/router/index.d.ts

@@ -0,0 +1,23 @@
+export declare class Rule {
+    name: string;
+    matchers: Record<string, string[]>;
+    output: Record<string, unknown>;
+    constructor(name: string, matchers: Record<string, string[]>, output: Record<string, unknown>);
+    matches(msg: Record<string, unknown>): boolean;
+    outputFor(msg: Record<string, unknown>): Record<string, unknown>;
+}
+interface RouteResult {
+    team: string;
+    kv_version: string;
+    kv_language: string;
+    routes: Record<string, unknown>[];
+}
+export declare class Router {
+    rules: Rule[];
+    constructor(rules?: Rule[]);
+    loadConfig(filename: string): void;
+    _loadConfigString(configStr: string): void;
+    route(msg: Record<string, unknown>): RouteResult;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/router/index.ts"],"names":[],"mappings":"AA2EA,qBAAa,IAAI;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEpB,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAkC7F,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAS9C,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAsBjE;AA4CD,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CACnC;AAED,qBAAa,MAAM;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;gBAEF,KAAK,CAAC,EAAE,IAAI,EAAE;IAI1B,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKlC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQ1C,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,WAAW;CAgBjD"}