@lakutata/logger 0.0.0-stage → 3.0.0-beta.1

package/dist/types/Logger.d.ts

@@ -0,0 +1,291 @@
+import { Component } from '@lakutata/core';
+import type { ILogger } from '@lakutata/core/com/logger';
+/**
+ * The logger component of the applications built with `lakutata`: the package presets it as the `log` component (and
+ * creates it first), so the framework and the application log through it. It writes the pino log format: one JSON
+ * object per line, with `level` (10 trace, 20 debug, 30 info, 40 warn, 50 error, 60 fatal), `time` (milliseconds since the epoch),
+ * `pid`, `hostname`, `name` (the application's name), the properties of the logged object and `msg`; with `pretty` on
+ * (the default), it writes readable lines instead: `[HH:MM:ss.SSS] LEVEL (name/pid): message`, then one indented line
+ * per property, in the local time zone.
+ *
+ * Configure it through the `log` entry of the application's `components` (no `class` needed:
+ * `log: {level: 'info', pretty: false}`), and get it with `@Inject('log')` or `getObject('log')`; it is a singleton.
+ * The lines are buffered and written at the next turn of the event loop (or once 16 KB are pending), and the pending
+ * lines are written synchronously when the process exits or the component is destroyed; `sync: true` writes each line
+ * at once instead. A stream with a file descriptor (stdout, stderr, an opened file) is written synchronously through
+ * it, so the lines keep their order.
+ *
+ * An HTTP request or response logged as the object of a line is written under `req` or `res` with the values of its
+ * credential headers (`Authorization`, `Cookie`, `Set-Cookie`, `Proxy-Authorization`) replaced by `[Redacted]` (see
+ * the `redactedHeaders` option). Nothing else is redacted and there are no child loggers: the other properties are
+ * written as is, so log the fields you need rather than secrets or whole objects holding them.
+ * @example
+ * ```typescript
+ * import {Application, Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ * import {Logger} from 'lakutata/com/logger'
+ *
+ * class Orders extends Component {
+ *     @Inject('log')
+ *     protected readonly log: Logger
+ *
+ *     public pay(orderId: number, amount: number): void {
+ *         //{"level":30,...,"orderId":42,"msg":"order 42 paid: 9.90"}
+ *         this.log.info({orderId: orderId}, 'order %d paid: %s', orderId, amount.toFixed(2))
+ *     }
+ *
+ *     public fail(error: Error): void {
+ *         //The error serialized under "err", its message as the message unless one is given
+ *         this.log.error(error, 'payment failed')
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     components: {
+ *         //The preset logger: JSON lines from the info level in production
+ *         log: {level: 'info', pretty: process.env.NODE_ENV !== 'production'},
+ *         orders: {class: Orders}
+ *     }
+ * }))
+ * ```
+ */
+export declare class Logger extends Component implements ILogger {
+    #private;
+    /**
+     * Write readable lines (`[HH:MM:ss.SSS] LEVEL (name/pid): message`, then the properties) when `true`, the JSON lines
+     * of pino when `false` (for a log collector).
+     * @default true
+     * @protected
+     */
+    protected readonly pretty: boolean;
+    /**
+     * The lowest level written: `'trace'`, `'debug'`, `'info'`, `'warn'`, `'error'`, `'fatal'` (only the lines of
+     * {@link Logger.fatal}) or `'silent'` (nothing); the lines of lower levels are dropped.
+     * @default 'trace'
+     * @protected
+     */
+    protected readonly level: string;
+    /**
+     * Color the readable lines written to `process.stdout` (the level, the message, the properties); the other
+     * destinations and the JSON lines are never colored.
+     * @default true
+     * @protected
+     */
+    protected readonly colorize: boolean;
+    /**
+     * Write each line at once when `true`; when `false`, the lines are buffered and written at the next turn of the
+     * event loop (or once 16 KB are pending), which costs less per line. The pending lines are written synchronously when
+     * the process exits either way.
+     * @default false
+     * @protected
+     */
+    protected readonly sync: boolean;
+    /**
+     * The streams the lines are written to, each receiving every line: `process.stdout`, `process.stderr`, a file
+     * (`fs.createWriteStream(path, {flags: 'a'})`) or any writable stream. The streams are not closed by the logger.
+     * @default [process.stdout]
+     * @protected
+     */
+    protected readonly destinations: NodeJS.WritableStream[];
+    /**
+     * The headers whose values are written as `[Redacted]` when an HTTP request or response (of `node:http`, Express,
+     * Fastify) is logged as the object of a line, by name (case-insensitive). The list replaces the default one: to
+     * redact another header, list the default ones with it; `[]` writes every header as is. The headers of the request
+     * or response are not changed.
+     * @default ['authorization', 'cookie', 'set-cookie', 'proxy-authorization']
+     * @protected
+     */
+    protected readonly redactedHeaders: string[];
+    /**
+     * Set up the destinations and the level, and register the logger to flush its pending lines when the process exits.
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Write the pending lines and stop flushing at the process exit.
+     * @protected
+     */
+    protected destroy(): Promise<void>;
+    /**
+     * Build a log line and write it to every destination, unless its level is below the configured `level`.
+     * @param level The numeric level of the line: 10 trace, 20 debug, 30 info, 40 warn, 50 error, 60 fatal.
+     * @param args The arguments of the log method: `[obj, msg, ...args]` or `[msg, ...args]`.
+     * @protected
+     */
+    protected write(level: number, args: unknown[]): void;
+    /**
+     * Write the buffered lines now, synchronously for the streams with a file descriptor (before a `process.exit()`
+     * in a signal handler, for instance). Does nothing with `sync: true`.
+     */
+    flush(): void;
+    /**
+     * Log a fatal error (a failure the application cannot continue after, logged before it exits) at the `fatal`
+     * level (60), unless the configured `level` is `'silent'`. The line and the pending ones are written at once, as
+     * by {@link Logger.flush}.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    fatal<T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    /**
+     * Log a fatal error (a failure the application cannot continue after, logged before it exits) at the `fatal`
+     * level (60), unless the configured `level` is `'silent'`. The line and the pending ones are written at once, as
+     * by {@link Logger.flush}.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    fatal(obj: unknown, msg?: string, ...args: any[]): void;
+    /**
+     * Log a fatal error (a failure the application cannot continue after, logged before it exits) at the `fatal`
+     * level (60), unless the configured `level` is `'silent'`. The line and the pending ones are written at once, as
+     * by {@link Logger.flush}.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    fatal(msg: string, ...args: any[]): void;
+    /**
+     * Log an error (a failure the application needs to act on) at the `error` level (50), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    error<T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    /**
+     * Log an error (a failure the application needs to act on) at the `error` level (50), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    error(obj: unknown, msg?: string, ...args: any[]): void;
+    /**
+     * Log an error (a failure the application needs to act on) at the `error` level (50), unless the configured `level` is higher.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    error(msg: string, ...args: any[]): void;
+    /**
+     * Log a warning (an unexpected event the application recovers from) at the `warn` level (40), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    warn<T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    /**
+     * Log a warning (an unexpected event the application recovers from) at the `warn` level (40), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    warn(obj: unknown, msg?: string, ...args: any[]): void;
+    /**
+     * Log a warning (an unexpected event the application recovers from) at the `warn` level (40), unless the configured `level` is higher.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    warn(msg: string, ...args: any[]): void;
+    /**
+     * Log an information (the normal course of the application) at the `info` level (30), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    info<T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    /**
+     * Log an information (the normal course of the application) at the `info` level (30), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    info(obj: unknown, msg?: string, ...args: any[]): void;
+    /**
+     * Log an information (the normal course of the application) at the `info` level (30), unless the configured `level` is higher.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    info(msg: string, ...args: any[]): void;
+    /**
+     * Log a debugging detail at the `debug` level (20), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    debug<T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    /**
+     * Log a debugging detail at the `debug` level (20), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    debug(obj: unknown, msg?: string, ...args: any[]): void;
+    /**
+     * Log a debugging detail at the `debug` level (20), unless the configured `level` is higher.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    debug(msg: string, ...args: any[]): void;
+    /**
+     * Log a tracing detail, finer than debug at the `trace` level (10), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    trace<T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    /**
+     * Log a tracing detail, finer than debug at the `trace` level (10), unless the configured `level` is higher.
+     * @param obj The properties added to the line (`{orderId: 42}`). An `Error` is written under `err` (its type,
+     * message, stack, causes and own properties), its message becoming the message when `msg` is omitted; an HTTP
+     * request or response of `node:http` is written under `req` or `res`, its credential headers redacted.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    trace(obj: unknown, msg?: string, ...args: any[]): void;
+    /**
+     * Log a tracing detail, finer than debug at the `trace` level (10), unless the configured `level` is higher.
+     * @param msg The message, with printf-style placeholders replaced by `args`: `%s` (string), `%d` and `%f` (number),
+     * `%i` (integer), `%o`, `%O` and `%j` (JSON), `%%` (a percent sign).
+     * @param args The values of the placeholders of `msg`, in order; the values without a placeholder are dropped.
+     */
+    trace(msg: string, ...args: any[]): void;
+}

package/dist/types/exports/Logger.d.ts

@@ -0,0 +1,2 @@
+export * from '../Logger.js';
+export type { ILogger, ILogMethod } from '@lakutata/core/com/logger';

package/dist/types/lib/Colors.d.ts

@@ -0,0 +1,8 @@
+export type Colorize = (input: unknown) => string;
+export type Palette = {
+    level: Record<string, Colorize>;
+    message: Colorize;
+    property: Colorize;
+};
+export declare const PLAIN_PALETTE: Palette;
+export declare const COLOR_PALETTE: Palette;

package/dist/types/lib/Destination.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A destination of the log lines, buffered unless synchronous
+ * The buffered lines are written in the next event loop iteration, and synchronously when the process exits
+ * The streams with a file descriptor (stdout, stderr, files) are written through it, so the lines stay in order
+ */
+export declare class Destination {
+    #private;
+    protected readonly stream: NodeJS.WritableStream;
+    protected readonly sync: boolean;
+    constructor(stream: NodeJS.WritableStream, sync: boolean);
+    /**
+     * The file descriptor of the stream, if it has one
+     * @protected
+     */
+    protected get fd(): number | undefined;
+    /**
+     * Write a text to the file descriptor, retrying when the descriptor is busy
+     * @param fd
+     * @param text
+     * @protected
+     */
+    protected writeFd(fd: number, text: string): void;
+    /**
+     * Write a text
+     * @param text
+     */
+    write(text: string): void;
+    /**
+     * Write a text to the stream, through its file descriptor if it has one
+     * @param text
+     * @protected
+     */
+    protected output(text: string): void;
+    /**
+     * Write the buffered text
+     */
+    flush(): void;
+}

package/dist/types/lib/Format.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Format a log message with its arguments: %s, %d, %f, %i, %o, %O, %j and %%
+ * The arguments without placeholder are ignored
+ * @param template
+ * @param args
+ */
+export declare function format(template: unknown, args: unknown[]): unknown;

package/dist/types/lib/Pretty.d.ts

@@ -0,0 +1,9 @@
+import { Palette } from './Colors.js';
+/**
+ * Format a JSON log line for humans:
+ * [time] LEVEL (name/pid): message, then the properties on their own lines
+ * @param line the JSON log line, without its line terminator
+ * @param palette
+ * @param parsed the parsed line, if it is known (the log is changed)
+ */
+export declare function pretty(line: string, palette: Palette, parsed?: Record<string, unknown>): string;

package/dist/types/lib/Record.d.ts

@@ -0,0 +1,25 @@
+export declare const LEVELS: Record<string, number>;
+export type LogBindings = {
+    json: string;
+    name: string;
+};
+export type LogRecord = {
+    line: string;
+    log?: Record<string, unknown>;
+};
+/**
+ * The bindings of the log lines of an application: pid, hostname and name
+ * @param name
+ */
+export declare function logBindings(name: string): LogBindings;
+/**
+ * Build a JSON log line from the arguments of a log method:
+ * an object (or error, HTTP request or response) with an optional message and its format arguments,
+ * or a message with its format arguments
+ * @param level
+ * @param bindings
+ * @param args
+ * @param parse whether to also build the parsed line
+ * @param redacted the lower-case names of the headers of an HTTP request or response written as [Redacted]
+ */
+export declare function buildRecord(level: number, bindings: LogBindings, args: unknown[], parse?: boolean, redacted?: ReadonlySet<string>): LogRecord;

package/dist/types/lib/Serializers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Whether a value looks like an error
+ * @param value
+ */
+export declare function isErrorLike(value: any): boolean;
+/**
+ * Serialize an error: type, message and stack (with the causes), aggregated errors and the other enumerable properties
+ * @param error
+ */
+export declare function serializeError(error: any): any;
+/**
+ * The headers written as [Redacted] by default: the credentials of the requests and of the responses
+ */
+export declare const REDACTED_HEADERS: readonly string[];
+/**
+ * Serialize an HTTP request
+ * @param request
+ * @param redacted the lower-case names of the headers written as [Redacted]
+ */
+export declare function serializeRequest(request: any, redacted?: ReadonlySet<string>): Record<string, unknown>;
+/**
+ * Serialize an HTTP response
+ * @param response
+ * @param redacted the lower-case names of the headers written as [Redacted]
+ */
+export declare function serializeResponse(response: any, redacted?: ReadonlySet<string>): Record<string, unknown>;

package/dist/types/lib/Stringify.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Serialize a value to JSON, the values JSON cannot serialize are serialized safely
+ * @param value
+ */
+export declare function stringify(value: unknown): string | undefined;

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@lakutata/logger",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.0.0-beta.1",
+  "description": "The logger component of the lakutata framework.",
+  "type": "module",
+  "main": "./dist/cjs/exports/Logger.js",
+  "types": "./dist/cjs/exports/Logger.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/exports/Logger.d.ts",
+        "default": "./dist/esm/exports/Logger.js"
+      },
+      "require": {
+        "types": "./dist/cjs/exports/Logger.d.ts",
+        "default": "./dist/cjs/exports/Logger.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', {recursive: true, force: true})\"",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs-pkg": "node ../../scripts/package-build/cjs-package.mjs",
+    "build:js": "npm run build:cjs && npm run build:esm && npm run build:cjs-pkg",
+    "rebuild": "npm run clean && npm run build:js",
+    "compile": "npm run rebuild",
+    "test:unit": "npm run compile && node --test \"dist/esm/tests/*.spec.js\""
+  },
+  "peerDependencies": {
+    "@lakutata/core": "3.0.0-beta.1"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "!dist/*/tests",
+    "*.md",
+    "LICENSE",
+    "package.json",
+    "THIRD_PARTY_NOTICES.md"
+  ]
+}