halua 0.0.5 → 1.1.0

package/lib/index.js

@@ -1,177 +1,685 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  Level: () => Level,
-  halua: () => halua
-});
-module.exports = __toCommonJS(index_exports);
-
-// types.ts
+// src/handlers/types.ts
 var Level = /* @__PURE__ */ ((Level2) => {
+  Level2["Trace"] = "TRACE";
   Level2["Debug"] = "DEBUG";
   Level2["Info"] = "INFO";
+  Level2["Notice"] = "NOTICE";
   Level2["Warn"] = "WARN";
-  Level2["Error"] = "ERR";
+  Level2["Error"] = "ERROR";
+  Level2["Fatal"] = "FATAL";
   return Level2;
 })(Level || {});
 
-// loggerCore.ts
-var LoggerCore = class _LoggerCore {
-  handler = self?.console || window?.console;
-  dateGetter = null;
-  options = {};
-  levelMapping = /* @__PURE__ */ new Map([
-    ["debug", "DEBUG" /* Debug */],
-    ["info", "INFO" /* Info */],
-    ["warn", "WARN" /* Warn */],
-    ["error", "ERR" /* Error */]
-  ]);
-  constructor(handler, options = {}) {
-    if (handler) {
-      this.handler = handler;
-    }
-    if (options.dateGetter) {
-      this.dateGetter = options.dateGetter;
-      delete options.dateGetter;
-    }
-    this.options = {
-      ...this.options,
-      ...options
-    };
+// src/util/level.ts
+function toLevel(v) {
+  return {
+    trace: "TRACE" /* Trace */,
+    debug: "DEBUG" /* Debug */,
+    info: "INFO" /* Info */,
+    warn: "WARN" /* Warn */,
+    notice: "NOTICE" /* Notice */,
+    error: "ERROR" /* Error */,
+    fatal: "FATAL" /* Fatal */,
+    assert: "ERROR" /* Error */
+  }[v];
+}
+
+// src/util/string.ts
+var defaultIgnored = /* @__PURE__ */ new Set();
+function stringMatchesVar(str, ignoredStrings = defaultIgnored) {
+  return !ignoredStrings.has(str) && str.trim().indexOf(" ") === -1;
+}
+var messageFormatExcludes = /* @__PURE__ */ new Set([" ", "%a", "%w", "%t", "%l"]);
+function extractNonFormatChars(f) {
+  let total = /* @__PURE__ */ new Set();
+  for (let char of f) {
+    if (!messageFormatExcludes.has(char)) {
+      total.add(char);
+    }
+  }
+  return total;
+}
+function extractTaken(f) {
+  let total = [];
+  let seq = "";
+  for (let rune of f) {
+    if (seq && (rune === "%" || rune === " ")) {
+      total.push(seq);
+      seq = "";
+      if (rune === "%") {
+        seq += rune;
+      }
+      continue;
+    }
+    seq += rune;
+  }
+  if (seq) {
+    total.push(seq);
+  }
+  return total;
+}
+function removeTailingUndefinedValues(format, log) {
+  if (!argsInDisposition(format) || log.withArgs) {
+    return format;
+  }
+  let argsIndex = format.indexOf("%a");
+  let withArgsIndex = format.indexOf("%w");
+  if (withArgsIndex < argsIndex) {
+    return format;
+  }
+  return format.slice(0, argsIndex + 2);
+}
+function argsInDisposition(format) {
+  let indexOfArgs = format.indexOf("%a");
+  let indexOfWithArgs = format.indexOf("%w");
+  let indexOfTimestamp = format.indexOf("%t");
+  let indexOfLevel = format.indexOf("l");
+  return Math.max(indexOfTimestamp, indexOfLevel) < Math.min(indexOfArgs, indexOfWithArgs);
+}
+function getConvertStartingIndex(format) {
+  let sum = format.indexOf("%t") + format.indexOf("%l");
+  if (sum === -2) {
+    return 0;
   }
-  New(handler = this.handler, options = this.options) {
-    return new _LoggerCore(handler, options);
+  if (sum === 0) {
+    return 1;
   }
-  With(msg, ...args) {
-    let postfix = this.options.postfix ? `${this.options.postfix} ${this.composeMsgWithArgs(msg, ...args)}` : this.composeMsgWithArgs(msg, ...args);
-    return new _LoggerCore(this.handler, {
-      postfix,
-      dateGetter: this.dateGetter,
-      minLevel: this.options.minLevel
-    });
+  return 2;
+}
+function extractLevels(level) {
+  if (typeof level !== "string") {
+    return ["INFO" /* Info */, 0];
   }
-  debug(msg, ...args) {
-    if (this.canLogByMinLevelRestriction("DEBUG" /* Debug */)) {
-      this.log("debug", msg, ...args);
+  let data = level.split("+");
+  if (data.length !== 2) {
+    let levels = ["TRACE" /* Trace */, "DEBUG" /* Debug */, "INFO" /* Info */, "WARN" /* Warn */, "NOTICE" /* Notice */, "ERROR" /* Error */, "FATAL" /* Fatal */];
+    for (let l of levels) {
+      if (level.includes(l)) {
+        return [l, Math.trunc(level.split(l)[1])];
+      }
     }
   }
-  info(msg, ...args) {
-    if (this.canLogByMinLevelRestriction("INFO" /* Info */)) {
-      this.log("info", msg, ...args);
+  return [data[0], Math.trunc(data[1]) || 0];
+}
+
+// src/errors.ts
+var FailedToCallHandlerLog = class extends Error {
+};
+
+// src/HandlersBalancer.ts
+var MajorLevelMap = /* @__PURE__ */ new Map([
+  ["FATAL" /* Fatal */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */])],
+  ["ERROR" /* Error */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */, "ERROR" /* Error */])],
+  ["WARN" /* Warn */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */, "ERROR" /* Error */, "WARN" /* Warn */])],
+  ["NOTICE" /* Notice */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */, "ERROR" /* Error */, "WARN" /* Warn */, "NOTICE" /* Notice */])],
+  ["INFO" /* Info */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */, "ERROR" /* Error */, "WARN" /* Warn */, "NOTICE" /* Notice */, "INFO" /* Info */])],
+  ["DEBUG" /* Debug */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */, "ERROR" /* Error */, "WARN" /* Warn */, "NOTICE" /* Notice */, "INFO" /* Info */, "DEBUG" /* Debug */])],
+  ["TRACE" /* Trace */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */, "ERROR" /* Error */, "WARN" /* Warn */, "NOTICE" /* Notice */, "INFO" /* Info */, "DEBUG" /* Debug */, "TRACE" /* Trace */])]
+]);
+var HandlersBalancer = class {
+  constructor(level, handlers) {
+    this.level = level;
+    this.handlers = handlers;
+  }
+  map = /* @__PURE__ */ new Map();
+  sendLog(log) {
+    this.discover(log.level);
+    this.send(log);
+  }
+  reset() {
+    this.map.clear();
+  }
+  discover(level) {
+    if (this.map.get(level)) {
+      return;
+    }
+    let discovered = [];
+    this.map.set(level, discovered);
+    for (let h of this.handlers) {
+      if (h.exact) {
+        if (h.exact.some((l) => l === level)) {
+          discovered.push(h);
+        }
+        continue;
+      }
+      if (this.canSend(extractLevels(level), h.level)) {
+        discovered.push(h);
+      }
     }
   }
-  warn(msg, ...args) {
-    if (this.canLogByMinLevelRestriction("WARN" /* Warn */)) {
-      this.log("warn", msg, ...args);
+  send(log) {
+    try {
+      for (let h of this.map.get(log.level) || []) {
+        h.skipDeepCopyWhenSendingLog ? h.log(log) : h.log(structuredClone(log));
+      }
+    } catch (e) {
+      throw new FailedToCallHandlerLog(`Unable to call .log method of a handler, ${e}`, { cause: e });
     }
   }
-  err(msg, ...args) {
-    this.log("error", msg, ...args);
+  canSend(l, to = this.level || "TRACE" /* Trace */) {
+    let tol = extractLevels(to);
+    return this.majorLevelCheck(l[0], tol[0]) + this.minorLevelCheck(l[1], tol[1]) > 0;
   }
-  assert(value, msg, ...args) {
-    if (!value) {
-      this.log("error", `assertion failed: ${msg}`, ...args);
+  majorLevelCheck(l, to) {
+    if (!MajorLevelMap.get(to).has(l)) {
+      return -1;
     }
+    return l === to ? 0 : 1;
+  }
+  minorLevelCheck(l, to) {
+    return l >= to ? 1 : 0;
+  }
+};
+
+// src/main.ts
+var Halua = class _Halua {
+  constructor(passed, options = {}) {
+    this.options = options;
+    this.passedHandlers = passed;
+    this.options.messageFormat ??= "%t %l %a | %w";
+    this.validateHandlers(this.buildHandlers(passed));
+    this.handlers = this.buildHandlers(passed);
+    this.balancer = new HandlersBalancer(this.options.level || "TRACE" /* Trace */, this.handlers);
+  }
+  handlers = [];
+  passedHandlers;
+  balancer;
+  New(arg1 = this.passedHandlers, arg2 = this.options) {
+    if (Array.isArray(arg1)) {
+      this.validateHandlers(this.buildHandlers(arg1));
+      return new _Halua(arg1, { ...arg2 });
+    }
+    if (this.supposeIsHandler(arg1)) {
+      return new _Halua(arg1, { ...arg2 });
+    }
+    if (Object.keys(arg1).length) {
+      return new _Halua(this.passedHandlers, { ...arg1 });
+    }
+    this.validateHandlers(this.buildHandlers(arg1));
+    return new _Halua(arg1, { ...arg2 });
+  }
+  With(...args) {
+    return new _Halua(this.passedHandlers, { ...this.options, withArgs: (this.options.withArgs || []).concat(args) });
+  }
+  withMessageFormat(f) {
+    this.unlinkInheritance();
+    this.options.messageFormat = f;
+    return this;
   }
   setHandler(handler) {
-    this.handler = handler;
-  }
-  setDateGetter(getter) {
-    this.dateGetter = getter;
-  }
-  log(to, msg, ...args) {
-    let value = msg;
-    value = this.composeMsgWithArgs(value, ...args);
-    if (this.options.postfix) {
-      value = this.appendValue(this.options.postfix, value);
-    }
-    let level = this.levelMapping.get(to);
-    value = this.formatWithDate(this.formatWithLevel(level, value));
-    this.handler[to](value);
-  }
-  composeMsgWithArgs(msg, ...args) {
-    if (args.length === 1) {
-      return this.appendValue(args[0], msg);
-    }
-    let totalMsg = msg;
-    let key = "";
-    for (let arg of args) {
-      if (!key) {
-        key = arg;
-        continue;
+    this.validateHandlers(this.buildHandlers(handler));
+    this.handlers = this.buildHandlers(handler);
+    this.updateBalancer();
+  }
+  appendHandler(handler) {
+    this.validateHandlers(this.buildHandlers(handler));
+    this.handlers.push(...this.buildHandlers(handler));
+    this.updateBalancer();
+  }
+  logTo(level, ...args) {
+    this.balancer.sendLog(this.composeLog(level, true, ...args));
+  }
+  trace(...args) {
+    this.sendToHandler("trace", true, ...args);
+  }
+  debug(...args) {
+    this.sendToHandler("debug", true, ...args);
+  }
+  info(...args) {
+    this.sendToHandler("info", true, ...args);
+  }
+  warn(...args) {
+    this.sendToHandler("warn", true, ...args);
+  }
+  notice(...args) {
+    this.sendToHandler("notice", true, ...args);
+  }
+  error(...args) {
+    this.sendToHandler("error", true, ...args);
+  }
+  fatal(...args) {
+    this.sendToHandler("fatal", true, ...args);
+  }
+  assert(assertion, ...args) {
+    if (assertion) {
+      return;
+    }
+    this.sendToHandler("assert", assertion, ...args);
+  }
+  updateBalancer() {
+    this.balancer = new HandlersBalancer(this.options.level || "TRACE" /* Trace */, this.handlers);
+  }
+  sendToHandler(field, assertion = true, ...args) {
+    this.balancer.sendLog(this.composeLog(toLevel(field), assertion, ...args));
+  }
+  composeLog(level, assertion, ...args) {
+    return {
+      timestamp: Date.now(),
+      args: args || [],
+      withArgs: this.options?.withArgs || null,
+      messageFormat: this.options.messageFormat,
+      assertion,
+      level,
+      leveling: extractLevels(level)
+    };
+  }
+  validateHandlers(v) {
+    let handlers = Array.isArray(v) ? v : [v];
+    if (this.options.errorPolicy === "throw") {
+      for (let h of handlers) {
+        if (!this.supposeIsHandler(h)) {
+          throw new Error("Passed handlers does not satisfy Handler interface");
+        }
+      }
+    }
+  }
+  supposeIsHandler(v) {
+    return Object.prototype.hasOwnProperty.call(v.__proto__, "log") || Object.prototype.hasOwnProperty.call(v, "log");
+  }
+  unlinkInheritance() {
+    this.options = structuredClone(this.options);
+  }
+  buildHandlers(passed) {
+    let entries = Array.isArray(passed) ? passed : [passed];
+    return entries.map((v) => v());
+  }
+};
+
+// src/handlers/WebConsoleHandler/webConsoleUtils.ts
+function getColorKey(level) {
+  return {
+    ["TRACE" /* Trace */]: "grey",
+    ["DEBUG" /* Debug */]: "purple",
+    ["INFO" /* Info */]: "blue",
+    ["WARN" /* Warn */]: "orange",
+    ["NOTICE" /* Notice */]: "orange",
+    ["ERROR" /* Error */]: "red",
+    ["FATAL" /* Fatal */]: "red"
+  }[level];
+}
+
+// src/util/array.ts
+function arrayed(v) {
+  return Array.isArray(v) ? v : typeof v === "undefined" ? [] : [v];
+}
+
+// src/util/date.ts
+function getPrettyDate(t) {
+  let d = new Date(t);
+  return `${d.toLocaleDateString()} ${d.toLocaleTimeString()}`;
+}
+
+// src/handlers/WebConsoleHandler/WebConsoleHandler.ts
+function NewWebConsoleHandler(c = console, options = {}) {
+  return () => new class WebConsoleLog {
+    constructor(options2) {
+      this.options = options2;
+      this.level = options2.level;
+      this.exact = options2.exact ? arrayed(options2.exact) : void 0;
+      this.options = options2 || {};
+      this.options.fetchBrowserThemeOnInstanceCreation ??= true;
+      this.messageFormatRaw = options2.messageFormat ?? this.messageFormatRaw;
+      this.messageFormat = Array.from(extractTaken(this.messageFormatRaw));
+      if (!this.options.pretty) {
+        return;
       }
-      totalMsg = this.appendValue(`${key}="${arg}"`, totalMsg);
-      key = "";
+      if (this.options.fetchBrowserThemeOnInstanceCreation) {
+        if (window?.matchMedia && window?.matchMedia("(prefers-color-scheme: dark)").matches) {
+          this.colors = new Map(this.darkColors);
+        } else {
+          this.colors = new Map(this.lightColors);
+        }
+        delete this.options.fetchBrowserThemeOnInstanceCreation;
+      } else {
+        this.colors = new Map(this.lightColors);
+      }
+    }
+    skipDeepCopyWhenSendingLog = false;
+    messageFormat = [];
+    level;
+    exact;
+    messageFormatRaw = "%t %l %a | %w";
+    colors = /* @__PURE__ */ new Map([]);
+    // bg chrome #fefbff
+    lightColors = /* @__PURE__ */ new Map([
+      ["grey", "#565656"],
+      ["green", "#224912"],
+      ["blue", "#195367"],
+      ["purple", "#8A228A"],
+      ["orange", "#7F3E1E"],
+      ["red", "#A51818"]
+    ]);
+    // bg chrome #27242a
+    darkColors = /* @__PURE__ */ new Map([
+      ["grey", "#C9C9C9"],
+      ["green", "#73CE73"],
+      ["blue", "#93B9E7"],
+      ["purple", "#DCA4E9"],
+      ["orange", "#EEC5A8"],
+      ["red", "#FC9292"]
+    ]);
+    get linkArguments() {
+      return this.options.linkArguments !== void 0 && !this.options.linkArguments;
+    }
+    log(log) {
+      this.sendLog(log);
+    }
+    setDateGetter(dateGetter) {
+      this.options.dateGetter = dateGetter;
     }
-    if (key) {
-      totalMsg = this.appendValue(`${key}=${void 0}`, totalMsg);
+    sendLog(log) {
+      let args = this.insertInternalEntries(log);
+      if (log.level === "DEBUG" /* Debug */) {
+        c.debug(this.composeConsoleSubstitution(args), ...args);
+        return;
+      }
+      if (log.level === "WARN" /* Warn */ && this.options.useWarn) {
+        c.warn(this.composeConsoleSubstitution(args), ...args);
+        return;
+      }
+      if (log.level === "ERROR" /* Error */ && this.options.useError) {
+        c.error(this.composeConsoleSubstitution(args), ...args);
+        return;
+      }
+      c.info(this.composeConsoleSubstitution(args), ...args);
     }
-    return totalMsg;
+    insertInternalEntries(log) {
+      if (this.options.pretty) {
+        return this.prepareMessagePretty(log);
+      }
+      return this.prepareMessage(log);
+    }
+    composeConsoleSubstitution(data, startingVarConvertIndex = 2) {
+      let str = "";
+      startingVarConvertIndex = getConvertStartingIndex(this.messageFormatRaw);
+      if (this.options.pretty) {
+        startingVarConvertIndex = 3;
+      }
+      for (let i = this.options.pretty ? startingVarConvertIndex : 0; i < data.length; i++) {
+        let last = i === data.length - 1;
+        let v = data[i];
+        let takenNames = extractTaken(this.messageFormatRaw);
+        let vWithEqualSign = typeof v === "string" && stringMatchesVar(v, /* @__PURE__ */ new Set([]));
+        let nextVWithEqualSign = !last && typeof data[i + 1] === "string" && stringMatchesVar(data[i + 1], /* @__PURE__ */ new Set([]));
+        if (nextVWithEqualSign) {
+          startingVarConvertIndex = Math.max(startingVarConvertIndex, i);
+        }
+        if (!this.linkArguments && !takenNames.includes(v) && !last && i > startingVarConvertIndex && vWithEqualSign) {
+          data[i] = `${v} =`;
+        }
+        if (typeof v === "string") {
+          str += `%s${last ? "" : " "}`;
+          continue;
+        }
+        if (typeof v === "number") {
+          str += `%d${last ? "" : " "}`;
+          continue;
+        }
+        str += `%o${last ? "" : " "}`;
+      }
+      return str;
+    }
+    prepareMessagePretty(log) {
+      let format = [...this.messageFormat];
+      if (!log.withArgs) {
+        format = format.slice(0, format.indexOf("%a") + 1);
+      }
+      let message = [];
+      let colors = "";
+      let colorKeys = [];
+      for (let i = 0; i <= format.length - 1; i++) {
+        if (format[i] === "%w") {
+          message.push(...log.withArgs || []);
+          continue;
+        }
+        if (format[i] === "%t") {
+          colors += `%c${this.prepareDate(log.timestamp)} `;
+          colorKeys.push(`color:${this.options.customColors?.get("grey") || this.colors.get("grey")}`);
+          continue;
+        }
+        if (format[i] === "%a") {
+          colors += "%c";
+          colorKeys.push(`color:${this.options.customColors?.get("green") || this.colors.get("green")}`);
+          message.push(...log.args);
+          continue;
+        }
+        if (format[i] === "%l") {
+          colors += `%c${log.level}`;
+          let colorKey = getColorKey(log.leveling[0]);
+          colorKeys.push(`color:${this.options.customColors?.get(colorKey) || this.colors.get(colorKey)}`);
+          continue;
+        }
+        message.push(format[i]);
+      }
+      return [colors, ...colorKeys, ...message];
+    }
+    prepareMessage(log) {
+      let format = [...this.messageFormat];
+      if (!log.withArgs) {
+        format = format.slice(0, format.indexOf("%a") + 1);
+      }
+      let message = [];
+      for (let i = 0; i <= format.length - 1; i++) {
+        if (format[i] === "%w") {
+          message.push(...log.withArgs || []);
+          continue;
+        }
+        if (format[i] === "%t") {
+          message.push(this.prepareDate(log.timestamp));
+          continue;
+        }
+        if (format[i] === "%a") {
+          message.push(...log.args);
+          continue;
+        }
+        if (format[i] === "%l") {
+          message.push(log.level);
+          continue;
+        }
+        message.push(format[i]);
+      }
+      return message;
+    }
+    prepareDate(t) {
+      if (this.options.dateGetter) {
+        return this.options.dateGetter(t);
+      }
+      return getPrettyDate(t);
+    }
+  }(options);
+}
+
+// src/util/dataReplacer.ts
+function replaceDataBeforeStringify(value) {
+  if (typeof value === "symbol") {
+    return value.toString();
   }
-  formatWithLevel(level, msg) {
-    return this.shiftValue(level, msg);
+  if (value instanceof Set) {
+    return Array.from(value);
   }
-  formatWithDate(msg) {
-    if (this.dateGetter) {
+  if (value instanceof Map) {
+    let obj = {};
+    for (let key of value.keys()) {
+      obj[key] = value.get(key);
+    }
+    return obj;
+  }
+  if (value instanceof Error) {
+    return value.toString();
+  }
+  return value;
+}
+
+// src/handlers/JSONHandler/JSONHandler.ts
+function NewJSONHandler(send, options = {}) {
+  return () => new class JSONLog {
+    constructor(options2) {
+      this.options = options2;
+      this.level = options2.level;
+      this.exact = options2.exact ? arrayed(options2.exact) : void 0;
+      this.options = options2 || {};
+    }
+    level;
+    exact;
+    takenNames = /* @__PURE__ */ new Set(["timestamp", "level", "args"]);
+    log(log) {
+      this.sendLog(log);
+    }
+    setDateGetter(getter) {
+      this.options.dateGetter = getter;
+    }
+    sendLog(log) {
       try {
-        return this.shiftValue(this.dateGetter().toString(), msg);
-      } catch (_) {
-        this.err("date getter catches an error, check your date getter func");
+        delete log.assertion;
+        delete log.messageFormat;
+        delete log.leveling;
+        log.timestamp = this.formatDate(log.timestamp);
+        send(JSON.stringify(this.flattenLinkedArguments(log), this.replacer.bind(this)));
+      } catch (err) {
+        if (log.level !== "ERROR" /* Error */) {
+          this.log({
+            args: [`err while trying to stringify JSON ${err}`],
+            timestamp: log.timestamp,
+            level: "ERROR" /* Error */,
+            leveling: ["ERROR" /* Error */, 0]
+          });
+        }
+      }
+    }
+    formatDate(timestamp) {
+      if (this.options?.dateGetter) {
+        return this.options.dateGetter(timestamp);
+      }
+      return new Date(timestamp).toISOString();
+    }
+    flattenLinkedArguments(log) {
+      if (this.options?.linkArguments !== void 0 && this.options?.linkArguments === false) {
+        return log;
+      }
+      if (log.withArgs) {
+        this.composeLogWithArgsFlattened(log);
+      }
+      delete log.withArgs;
+      return log;
+    }
+    composeLogWithArgsFlattened(log) {
+      let composedLog = log;
+      let name = "";
+      for (let arg of log.withArgs) {
+        if (typeof arg === "string" && stringMatchesVar(arg)) {
+          name = arg;
+          continue;
+        }
+        if (name && !this.takenNames.has(name)) {
+          composedLog[name] = arg;
+          name = "";
+          continue;
+        }
+        log.args?.push(arg);
       }
+      return log;
     }
-    return this.shiftValue(this.getDateInLocaleString(), msg);
+    replacer(_, value) {
+      if (this.options.replaceBeforeStringify) {
+        let v = this.options.replaceBeforeStringify(value);
+        if (v !== null) {
+          return v;
+        }
+      }
+      return replaceDataBeforeStringify(value);
+    }
+  }(options);
+}
+
+// src/util/stringify.ts
+function stringifyValue(value, stringifier = JSON.stringify) {
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (value instanceof Set) {
+    return `Set[${Array.from(value)}]`;
   }
-  shiftValue(value, to) {
-    return `${value} ${to}`;
+  if (value instanceof Error) {
+    return value.toString();
   }
-  appendValue(value, to) {
-    return `${to} ${value}`;
+  if (Array.isArray(value)) {
+    return `[${value}]`;
   }
-  getDateInLocaleString() {
-    let d = /* @__PURE__ */ new Date();
-    return `${d.toLocaleDateString()} ${d.toLocaleTimeString()}`;
+  if (typeof value === "string") {
+    return `${value}`;
   }
-  canLogByMinLevelRestriction(level) {
-    const { minLevel } = this.options;
-    if (!minLevel || level === "ERR" /* Error */) {
-      return true;
+  return stringifier(value, (_, data) => replaceDataBeforeStringify(data));
+}
+
+// src/handlers/TextHandler/TextHandler.ts
+function NewTextHandler(send, options = {}) {
+  return () => new class TextLog {
+    constructor(options2) {
+      this.options = options2;
+      this.level = options2.level;
+      this.exact = options2.exact ? arrayed(options2.exact) : void 0;
+    }
+    skipDeepCopyWhenSendingLog = true;
+    level;
+    exact;
+    get linkArguments() {
+      return this.options.linkArguments !== void 0 && !this.options.linkArguments;
+    }
+    log(log) {
+      this.sendLog(log);
     }
-    if (level === "WARN" /* Warn */) {
-      return minLevel !== "ERR" /* Error */;
+    sendLog(log) {
+      let args = "";
+      let withArgs = "";
+      let msg = this.options.messageFormat || log.messageFormat;
+      if (log.args) {
+        args = this.composeVariablesString(msg, log.args);
+      }
+      if (log.withArgs) {
+        withArgs = this.composeVariablesString(msg, log.withArgs);
+      }
+      msg = removeTailingUndefinedValues(msg, log);
+      send(
+        msg.replace("%w", withArgs).replace("%a", args).replace("%l", log.level).replace(
+          "%t",
+          this.options.dateGetter?.(log.timestamp) ?? getPrettyDate(log.timestamp)
+        )
+      );
     }
-    if (level === "INFO" /* Info */) {
-      return minLevel !== "WARN" /* Warn */ && minLevel !== "ERR" /* Error */;
+    composeVariablesString(format, data) {
+      let str = "";
+      let excluded = extractNonFormatChars(format);
+      for (let i = 0; i < data.length; i++) {
+        let last = i === data.length - 1;
+        let nextIsNotLinked = typeof data[i + 1] === "string" && stringMatchesVar(data[i + 1], excluded);
+        let v = data[i];
+        if (!this.linkArguments && !last && typeof v === "string" && stringMatchesVar(v, excluded) && !nextIsNotLinked) {
+          str += `${v}=${this.formatValue(data[i + 1])} `;
+          i += 1;
+          continue;
+        }
+        str += `${this.formatValue(v)}${last ? "" : " "}`;
+      }
+      return str.trim();
     }
-    if (level === "DEBUG" /* Debug */) {
-      return minLevel === "DEBUG" /* Debug */;
+    formatValue(v) {
+      if (this.options.replaceBeforeStringify) {
+        let val = this.options.replaceBeforeStringify(v);
+        if (val !== null) {
+          return val;
+        }
+      }
+      return stringifyValue(v, this.options.stringifier);
     }
-    return true;
-  }
-};
+  }(options);
+}
 
-// index.ts
-var halua = new LoggerCore();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+// src/index.ts
+var halua = new Halua(NewWebConsoleHandler());
+export {
   Level,
+  NewJSONHandler,
+  NewTextHandler,
+  NewWebConsoleHandler,
   halua
-});
+};