halua 1.1.0 → 2.0.1

package/lib/index.js

@@ -1,4 +1,4 @@
-// src/handlers/types.ts
+// src/types/log.ts
 var Level = /* @__PURE__ */ ((Level2) => {
   Level2["Trace"] = "TRACE";
   Level2["Debug"] = "DEBUG";
@@ -10,82 +10,51 @@ var Level = /* @__PURE__ */ ((Level2) => {
   return Level2;
 })(Level || {});
 
-// 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);
-    }
+// src/main/getType.ts
+function getType(arg) {
+  if (typeof arg === "undefined") {
+    return "undefined";
   }
-  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 (typeof arg === "object" && String(arg) === "null") {
+    return "null";
   }
-  if (seq) {
-    total.push(seq);
+  if (Array.isArray(arg)) {
+    return "array";
   }
-  return total;
-}
-function removeTailingUndefinedValues(format, log) {
-  if (!argsInDisposition(format) || log.withArgs) {
-    return format;
+  if (ArrayBuffer.isView(arg)) {
+    return "typedarray";
   }
-  let argsIndex = format.indexOf("%a");
-  let withArgsIndex = format.indexOf("%w");
-  if (withArgsIndex < argsIndex) {
-    return format;
+  if (arg instanceof ArrayBuffer) {
+    return "arraybuffer";
   }
-  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;
+  if (arg instanceof Map) {
+    return "map";
+  }
+  if (arg instanceof Set) {
+    return "set";
+  }
+  if (arg instanceof WeakMap) {
+    return "weakmap";
+  }
+  if (arg instanceof WeakSet) {
+    return "weakset";
+  }
+  if (arg instanceof Date) {
+    return "date";
   }
-  if (sum === 0) {
-    return 1;
+  if (arg instanceof Error) {
+    return "error";
   }
-  return 2;
+  if (Number.isNaN(arg)) {
+    return "nan";
+  }
+  if (typeof arg === "number" && !Number.isFinite(arg)) {
+    return "infinity";
+  }
+  return typeof arg;
 }
+
+// src/main/util/string.ts
 function extractLevels(level) {
   if (typeof level !== "string") {
     return ["INFO" /* Info */, 0];
@@ -102,11 +71,33 @@ function extractLevels(level) {
   return [data[0], Math.trunc(data[1]) || 0];
 }
 
-// src/errors.ts
-var FailedToCallHandlerLog = class extends Error {
+// src/main/errors.ts
+var HaluaFailedToCallHandler = class extends Error {
+  constructor(message, options = {}) {
+    super(`HaluaFailedToCallHandlerError: ${message}`, options);
+  }
+};
+var HaluaUnableToDetermineHandler = class extends Error {
+  constructor(message, options = {}) {
+    super(`HaluaUnableToDetermineHandlerError: ${message}`, options);
+  }
+};
+var HaluaParse = class extends Error {
+  constructor(message, options = {}) {
+    super(`HaluaParseError: ${message}`, options);
+  }
 };
 
-// src/HandlersBalancer.ts
+// src/main/util/errors.ts
+function tryReportAnError(err) {
+  try {
+    let log = "self" in window ? self.console : console;
+    log.error(err);
+  } catch (_) {
+  }
+}
+
+// src/main/handlers/Balancer.ts
 var MajorLevelMap = /* @__PURE__ */ new Map([
   ["FATAL" /* Fatal */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */])],
   ["ERROR" /* Error */, /* @__PURE__ */ new Set(["FATAL" /* Fatal */, "ERROR" /* Error */])],
@@ -117,14 +108,17 @@ var MajorLevelMap = /* @__PURE__ */ new Map([
   ["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) {
+  constructor(level, handlers, format2) {
     this.level = level;
     this.handlers = handlers;
+    this.format = format2;
+    this.sendLog = this.sendLog.bind(this);
+    this.reset = this.reset.bind(this);
   }
   map = /* @__PURE__ */ new Map();
-  sendLog(log) {
-    this.discover(log.level);
-    this.send(log);
+  sendLog(meta, args) {
+    this.discover(meta.level);
+    this.send(meta, args);
   }
   reset() {
     this.map.clear();
@@ -142,23 +136,44 @@ var HandlersBalancer = class {
         }
         continue;
       }
-      if (this.canSend(extractLevels(level), h.level)) {
+      if (this.canSend(level, h.level ?? this.level)) {
         discovered.push(h);
       }
     }
   }
-  send(log) {
+  send(meta, args) {
     try {
-      for (let h of this.map.get(log.level) || []) {
-        h.skipDeepCopyWhenSendingLog ? h.log(log) : h.log(structuredClone(log));
-      }
+      this.sendToHandlers(meta, args);
     } catch (e) {
-      throw new FailedToCallHandlerLog(`Unable to call .log method of a handler, ${e}`, { cause: e });
+      tryReportAnError(new HaluaFailedToCallHandler(`Unable to call execution method of a handler`, { cause: e }));
+    }
+  }
+  sendToHandlers(meta, args) {
+    let generators = (this.map.get(meta.level) ?? []).map((h) => h.execute(meta));
+    generators.forEach((e) => e.next({ type: "init", value: null }));
+    let state = Array.from({ length: generators.length }).fill(void 0);
+    for (let arg of args) {
+      generators.forEach((e, i) => {
+        try {
+          let result = e.next({ type: "arg", value: arg, prev: state[i] });
+          state[i] = void 0;
+          if (result.value?.type === "pass") {
+            state[i] = this.format({ type: getType(arg), value: arg });
+          }
+        } catch (e2) {
+          tryReportAnError(new HaluaParse(`Failed to parse an argument`, { cause: e2 }));
+        }
+      });
     }
+    generators.forEach((e, i) => {
+      e.next({ type: "done", value: null, prev: state[i] });
+    });
+    state = [];
   }
   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;
+    let lvl = extractLevels(l);
+    let toLvl = extractLevels(to);
+    return this.majorLevelCheck(lvl[0], toLvl[0]) + this.minorLevelCheck(lvl[1], toLvl[1]) > 0;
   }
   majorLevelCheck(l, to) {
     if (!MajorLevelMap.get(to).has(l)) {
@@ -171,515 +186,477 @@ var HandlersBalancer = class {
   }
 };
 
-// src/main.ts
+// src/util/spacing.ts
+var Spacing = /* @__PURE__ */ ((Spacing2) => {
+  Spacing2["Space"] = " ";
+  Spacing2["Tab"] = "	";
+  Spacing2["Empty"] = "";
+  Spacing2["Line"] = "\n";
+  return Spacing2;
+})(Spacing || {});
+var EmptySpacing = /* @__PURE__ */ ((EmptySpacing2) => {
+  EmptySpacing2["Space"] = " ";
+  EmptySpacing2["Tab"] = "";
+  EmptySpacing2["Empty"] = "";
+  EmptySpacing2["Line"] = "";
+  return EmptySpacing2;
+})(EmptySpacing || {});
+
+// src/util/string.ts
+function printTimes(n, value) {
+  let str = "";
+  for (let i = n; i !== 0; i -= 1) {
+    str += value;
+  }
+  return str;
+}
+
+// src/main/format.ts
+var FormatAsIs = [
+  "undefined",
+  "null",
+  "string",
+  "number",
+  "boolean",
+  "symbol",
+  "typedarray",
+  "bigint",
+  "date",
+  "nan",
+  "infinity"
+];
+var FormatNeeded = [
+  "array",
+  "object",
+  "arraybuffer",
+  "map",
+  "set",
+  "weakmap",
+  "weakset",
+  "function",
+  "error"
+];
+function format(arg, spacing = true) {
+  try {
+    const SpacingEnum = spacing ? Spacing : EmptySpacing;
+    if (FormatAsIs.some((f) => f === arg.type)) {
+      return formatAsIs(arg.value, arg.type);
+    }
+    if (FormatNeeded.some((f) => f === arg.type)) {
+      return formatComplex(arg.value, arg.type, SpacingEnum);
+    }
+  } catch (err) {
+    return new HaluaParse(err?.message || "").message;
+  }
+  return arg.value;
+}
+function formatJSON(arg) {
+  if (arg.type === "error") {
+    return `${arg.value.toString()} stack: ${arg.value.stack?.replace("\n", "")}`;
+  }
+  return format(arg, false);
+}
+function formatAsIs(arg, type) {
+  if (type === "number") {
+    return arg;
+  }
+  if (type === "boolean") {
+    return arg;
+  }
+  return String(arg);
+}
+function formatComplex(arg, type, spacing, nestingLevel = 1) {
+  if (type === "set") {
+    return `Set${formatArray(convertSetToArray(arg), spacing)}`;
+  }
+  if (type === "weakset") {
+    return `WeakSet [inaccessible]`;
+  }
+  if (type === "weakmap") {
+    return `WeakMap {inaccessible}`;
+  }
+  if (type === "function") {
+    let name = arg.name;
+    return `Function ${name === "value" ? "anonymous" : name}`;
+  }
+  if (type === "array") {
+    return formatArray(arg, spacing);
+  }
+  if (type === "arraybuffer") {
+    return `ArrayBuffer []`;
+  }
+  if (type === "map") {
+    return formatObject(convertMapToObj(arg), spacing, nestingLevel, ` => `);
+  }
+  if (type === "error") {
+    return `${arg.toString()} stack: ${arg.stack}`;
+  }
+  if (type === "object") {
+    return formatObject(arg, spacing, nestingLevel);
+  }
+  return arg;
+}
+function formatArray(arg, spacing) {
+  let stringify = "[";
+  let len = arg.length;
+  for (let entry of arg) {
+    len -= 1;
+    let entryType = getType(entry);
+    let formatted = format({ type: entryType, value: entry });
+    let entryValue = entryType === "string" ? `"${formatted}"` : formatted;
+    stringify += `${entryValue}${len ? `,${spacing.Space}` : spacing.Empty}`;
+  }
+  stringify += "]";
+  return stringify;
+}
+function formatObject(arg, spacing, nestingLevel = 1, delimiter = `: `) {
+  let stringify = `{${spacing.Line}`;
+  let len = Object.keys(arg).length;
+  for (let key in arg) {
+    len -= 1;
+    let entryType = getType(arg[key]);
+    let formatted = entryType === "object" ? formatComplex(arg[key], entryType, spacing, nestingLevel + 1) : format({
+      type: entryType,
+      value: arg[key]
+    });
+    let entryValue = entryType === "string" ? `"${formatted}"` : formatted;
+    stringify += `${printTimes(nestingLevel, spacing.Tab)}"${key}"${delimiter}${entryValue}${len ? `,${spacing.Line}` : spacing.Empty}`;
+  }
+  let level = nestingLevel - 1;
+  stringify += `${spacing.Line}${printTimes(level, spacing.Tab)}}`;
+  return stringify;
+}
+function convertMapToObj(value) {
+  let obj = {};
+  for (let [key, v] of value) {
+    let keyType = getType(key);
+    let objKey = keyType === "string" ? key : format({ type: keyType, value: key });
+    let valueType = getType(v);
+    obj[objKey] = format({ type: valueType, value: v });
+  }
+  return obj;
+}
+function convertSetToArray(value) {
+  let arr = [];
+  for (let entry of value) {
+    arr.push(entry);
+  }
+  return arr;
+}
+
+// src/main/util/cast.ts
+function toarray(value) {
+  return Array.isArray(value) ? value : typeof value === "undefined" ? [] : [value];
+}
+
+// src/main/halua.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);
+    this.balancer = new HandlersBalancer(this.options.level || "TRACE" /* Trace */, this.handlers, format);
+    this.bindMethods();
   }
+  passedHandlers = [];
   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)) {
+    if (this.supposeIsHandler(arg1, false)) {
       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.validateHandlers(this.buildHandlers(handler));
+  setHandlers(handler) {
     this.handlers = this.buildHandlers(handler);
     this.updateBalancer();
   }
-  appendHandler(handler) {
-    this.validateHandlers(this.buildHandlers(handler));
-    this.handlers.push(...this.buildHandlers(handler));
+  appendHandlers(handler) {
+    let handlers = this.buildHandlers(handler);
+    this.handlers.push(...handlers);
     this.updateBalancer();
   }
   logTo(level, ...args) {
-    this.balancer.sendLog(this.composeLog(level, true, ...args));
+    this.sendToBalancer(level, args);
   }
   trace(...args) {
-    this.sendToHandler("trace", true, ...args);
+    this.sendToBalancer("TRACE" /* Trace */, args);
   }
   debug(...args) {
-    this.sendToHandler("debug", true, ...args);
+    this.sendToBalancer("DEBUG" /* Debug */, args);
   }
   info(...args) {
-    this.sendToHandler("info", true, ...args);
+    this.sendToBalancer("INFO" /* Info */, args);
   }
   warn(...args) {
-    this.sendToHandler("warn", true, ...args);
+    this.sendToBalancer("WARN" /* Warn */, args);
   }
   notice(...args) {
-    this.sendToHandler("notice", true, ...args);
+    this.sendToBalancer("NOTICE" /* Notice */, args);
   }
   error(...args) {
-    this.sendToHandler("error", true, ...args);
+    this.sendToBalancer("ERROR" /* Error */, args);
   }
   fatal(...args) {
-    this.sendToHandler("fatal", true, ...args);
+    this.sendToBalancer("FATAL" /* Fatal */, args);
   }
   assert(assertion, ...args) {
     if (assertion) {
       return;
     }
-    this.sendToHandler("assert", assertion, ...args);
+    this.sendToBalancer("ERROR" /* Error */, 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");
-        }
-      }
-    }
+    this.balancer = new HandlersBalancer(this.options.level || "TRACE" /* Trace */, this.handlers, format);
   }
-  supposeIsHandler(v) {
-    return Object.prototype.hasOwnProperty.call(v.__proto__, "log") || Object.prototype.hasOwnProperty.call(v, "log");
+  sendToBalancer(level, args) {
+    this.balancer.sendLog({ level, timestamp: Date.now() }, args.concat(this.options.withArgs ?? []));
   }
-  unlinkInheritance() {
-    this.options = structuredClone(this.options);
+  supposeIsHandler(v, reportError = true) {
+    const isHandler = Object.prototype.hasOwnProperty.call(v.__proto__, "execute") || Object.prototype.hasOwnProperty.call(v, "execute");
+    if (!isHandler && reportError) {
+      tryReportAnError(new HaluaUnableToDetermineHandler(`Unable to find execute method of a handler`));
+    }
+    return isHandler;
   }
   buildHandlers(passed) {
-    let entries = Array.isArray(passed) ? passed : [passed];
-    return entries.map((v) => v());
+    let entries = toarray(passed);
+    return entries.map((b) => b()).filter((h) => this.supposeIsHandler(h));
+  }
+  bindMethods() {
+    this.New = this.New.bind(this);
+    this.With = this.With.bind(this);
+    this.setHandlers = this.setHandlers.bind(this);
+    this.appendHandlers = this.appendHandlers.bind(this);
+    this.logTo = this.logTo.bind(this);
+    this.trace = this.trace.bind(this);
+    this.debug = this.debug.bind(this);
+    this.info = this.info.bind(this);
+    this.warn = this.warn.bind(this);
+    this.notice = this.notice.bind(this);
+    this.error = this.error.bind(this);
+    this.fatal = this.fatal.bind(this);
+    this.assert = this.assert.bind(this);
+    this.supposeIsHandler = this.supposeIsHandler.bind(this);
   }
 };
 
-// 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;
-      }
-      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;
-    }
-    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;
+// src/main/handlers/HandlerBase.ts
+var HandlerBase = class {
+  sendMethod;
+  formatArg = void 0;
+  level;
+  exact = null;
+  printTimestamp = true;
+  printLevel = true;
+  constructor(send) {
+    this.execute = this.execute.bind(this);
+    this.sendMethod = send ?? (() => {
+    });
+  }
+  *execute(meta) {
+    let arg = "";
+    let current = { value: null, type: "init" };
+    if (this.printTimestamp) {
+      arg += `${this.formatTimestamp(meta.timestamp)}`;
+    }
+    if (this.printLevel) {
+      arg += `  ${meta.level}`;
+    }
+    while (true) {
+      if (current.type === "init") {
+        current = yield { type: "init" };
       }
-      c.info(this.composeConsoleSubstitution(args), ...args);
-    }
-    insertInternalEntries(log) {
-      if (this.options.pretty) {
-        return this.prepareMessagePretty(log);
+      if (current.prev) {
+        arg += " " + current.prev;
       }
-      return this.prepareMessage(log);
-    }
-    composeConsoleSubstitution(data, startingVarConvertIndex = 2) {
-      let str = "";
-      startingVarConvertIndex = getConvertStartingIndex(this.messageFormatRaw);
-      if (this.options.pretty) {
-        startingVarConvertIndex = 3;
+      if (current.type === "done") {
+        break;
       }
-      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 ? "" : " "}`;
+      if (current.type === "arg") {
+        if (typeof this.formatArg === "function") {
+          arg += " " + this.formatArg(current.value);
+          current = yield { type: "done" };
           continue;
         }
-        str += `%o${last ? "" : " "}`;
       }
-      return str;
+      current = yield { type: "pass" };
+    }
+    this.sendMethod(arg.trimStart());
+  }
+  formatTimestamp(t) {
+    let d = new Date(t);
+    return `${d.toLocaleDateString()} ${d.toLocaleTimeString()}`;
+  }
+};
+
+// src/main/handlers/ConsoleHandler.ts
+function NewConsoleHandler(console2, options) {
+  return () => new class ConsoleHandler extends HandlerBase {
+    constructor(console3, options2 = {}) {
+      super();
+      this.console = console3;
+      this.applyOptionalOptions(options2);
+      this.level = options2.level;
+      this.exact = options2.exact ? toarray(options2.exact) : null;
     }
-    prepareMessagePretty(log) {
-      let format = [...this.messageFormat];
-      if (!log.withArgs) {
-        format = format.slice(0, format.indexOf("%a") + 1);
+    level;
+    exact = null;
+    formatArg = (arg) => arg;
+    applyOptionalOptions(options2) {
+      this.printTimestamp = options2.printTimestamp ?? true;
+      this.printLevel = options2.printLevel ?? true;
+    }
+    *execute(meta) {
+      let args = [];
+      let current = { value: null, type: "init" };
+      if (this.printTimestamp) {
+        args.push(`${this.formatTimestamp(meta.timestamp)}`);
       }
-      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 (this.printLevel) {
+        let margin = this.printTimestamp ? " " : "";
+        args.push(`${margin}${meta.level}`);
+      }
+      while (true) {
+        if (current.type === "init") {
+          current = yield { type: "init" };
         }
-        if (format[i] === "%t") {
-          colors += `%c${this.prepareDate(log.timestamp)} `;
-          colorKeys.push(`color:${this.options.customColors?.get("grey") || this.colors.get("grey")}`);
-          continue;
+        if (current.prev) {
+          args.push(current.prev);
         }
-        if (format[i] === "%a") {
-          colors += "%c";
-          colorKeys.push(`color:${this.options.customColors?.get("green") || this.colors.get("green")}`);
-          message.push(...log.args);
-          continue;
+        if (current.type === "done") {
+          break;
         }
-        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;
+        if (current.type === "arg") {
+          if (typeof this.formatArg === "function") {
+            args.push(current.value);
+            current = yield { type: "done" };
+            continue;
+          }
         }
-        message.push(format[i]);
+        current = yield { type: "pass" };
       }
-      return [colors, ...colorKeys, ...message];
-    }
-    prepareMessage(log) {
-      let format = [...this.messageFormat];
-      if (!log.withArgs) {
-        format = format.slice(0, format.indexOf("%a") + 1);
+      if (meta.level.startsWith("DEBUG")) {
+        this.console.debug(...args);
+        return;
       }
-      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]);
+      if (meta.level.startsWith("WARN")) {
+        this.console.warn(...args);
+        return;
       }
-      return message;
-    }
-    prepareDate(t) {
-      if (this.options.dateGetter) {
-        return this.options.dateGetter(t);
+      if (meta.level.startsWith("ERROR") || meta.level.startsWith("FATAL")) {
+        this.console.error(...args);
+        return;
       }
-      return getPrettyDate(t);
+      this.console.info(...args);
     }
-  }(options);
-}
-
-// src/util/dataReplacer.ts
-function replaceDataBeforeStringify(value) {
-  if (typeof value === "symbol") {
-    return value.toString();
-  }
-  if (value instanceof Set) {
-    return Array.from(value);
-  }
-  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;
+  }(console2, options);
 }
 
-// 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 || {};
-    }
+// src/main/handlers/JSONHandler.ts
+function NewJSONHandler(send, options) {
+  return () => new class JSONHandler extends HandlerBase {
     level;
-    exact;
-    takenNames = /* @__PURE__ */ new Set(["timestamp", "level", "args"]);
-    log(log) {
-      this.sendLog(log);
-    }
-    setDateGetter(getter) {
-      this.options.dateGetter = getter;
-    }
-    sendLog(log) {
-      try {
-        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]
-          });
-        }
-      }
+    exact = null;
+    constructor(send2, options2 = {}) {
+      super(send2);
+      this.applyOptionalOptions(options2);
+      this.level = options2.level;
+      this.exact = options2.exact ? toarray(options2.exact) : null;
     }
-    formatDate(timestamp) {
-      if (this.options?.dateGetter) {
-        return this.options.dateGetter(timestamp);
+    formatArg = (arg) => {
+      let type = getType(arg);
+      let formatted = formatJSON({ type, value: arg });
+      if (type !== "object" && type !== "map") {
+        return `"${formatted}"`;
       }
-      return new Date(timestamp).toISOString();
-    }
-    flattenLinkedArguments(log) {
-      if (this.options?.linkArguments !== void 0 && this.options?.linkArguments === false) {
-        return log;
+      return formatted;
+    };
+    *execute(meta) {
+      let arg = "{";
+      let current = { value: null, type: "init" };
+      if (this.printTimestamp) {
+        arg += `"timestamp":"${this.formatTimestamp(meta.timestamp)}",`;
       }
-      if (log.withArgs) {
-        this.composeLogWithArgsFlattened(log);
+      if (this.printLevel) {
+        arg += `"level":"${meta.level}",`;
       }
-      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;
+      arg += `"args":[`;
+      while (true) {
+        if (current.type === "init") {
+          current = yield { type: "init" };
         }
-        if (name && !this.takenNames.has(name)) {
-          composedLog[name] = arg;
-          name = "";
-          continue;
+        if (current.prev) {
+          arg += `"${current.prev}",`;
         }
-        log.args?.push(arg);
-      }
-      return log;
-    }
-    replacer(_, value) {
-      if (this.options.replaceBeforeStringify) {
-        let v = this.options.replaceBeforeStringify(value);
-        if (v !== null) {
-          return v;
+        if (current.type === "done") {
+          break;
         }
+        if (current.type === "arg") {
+          if (typeof this.formatArg === "function") {
+            arg += `${this.formatArg(current.value)},`;
+            current = yield { type: "done" };
+            continue;
+          }
+        }
+        current = yield { type: "pass" };
+      }
+      if (arg.at(-1) === ",") {
+        arg = arg.slice(0, arg.length - 1);
       }
-      return replaceDataBeforeStringify(value);
+      arg += `]}`;
+      this.sendMethod(arg);
     }
-  }(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)}]`;
-  }
-  if (value instanceof Error) {
-    return value.toString();
-  }
-  if (Array.isArray(value)) {
-    return `[${value}]`;
-  }
-  if (typeof value === "string") {
-    return `${value}`;
-  }
-  return stringifier(value, (_, data) => replaceDataBeforeStringify(data));
+    formatTimestamp(t) {
+      return new Date(t).toISOString();
+    }
+    applyOptionalOptions(options2) {
+      this.printTimestamp = options2.printTimestamp ?? true;
+      this.printLevel = options2.printLevel ?? true;
+    }
+  }(send, options);
 }
 
-// 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;
+// src/main/handlers/TextHandler.ts
+function NewTextHandler(send, options) {
+  return () => new class TextHandler extends HandlerBase {
     level;
-    exact;
-    get linkArguments() {
-      return this.options.linkArguments !== void 0 && !this.options.linkArguments;
-    }
-    log(log) {
-      this.sendLog(log);
-    }
-    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)
-        )
-      );
-    }
-    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();
+    exact = null;
+    formatArg;
+    constructor(send2, options2 = {}) {
+      super(send2);
+      this.applyOptionalOptions(options2);
+      this.level = options2.level;
+      this.exact = options2.exact ? toarray(options2.exact) : null;
+      this.formatArg = (value) => format({ type: getType(value), value }, options2.spacing);
     }
-    formatValue(v) {
-      if (this.options.replaceBeforeStringify) {
-        let val = this.options.replaceBeforeStringify(v);
-        if (val !== null) {
-          return val;
-        }
-      }
-      return stringifyValue(v, this.options.stringifier);
+    applyOptionalOptions(options2) {
+      this.printTimestamp = options2.printTimestamp ?? true;
+      this.printLevel = options2.printLevel ?? true;
     }
-  }(options);
+  }(send, options);
 }
 
 // src/index.ts
-var halua = new Halua(NewWebConsoleHandler());
+var logConsole = null;
+try {
+  logConsole = typeof self !== "undefined" ? self.console : console;
+} catch (_) {
+}
+var halua = new Halua(logConsole ? NewConsoleHandler(logConsole) : []);
 export {
   Level,
+  NewConsoleHandler,
   NewJSONHandler,
   NewTextHandler,
-  NewWebConsoleHandler,
   halua
 };