halua 3.0.0 → 4.0.2

package/lib/index.js

@@ -1,4 +1,3 @@
-// src/types/log.ts
 var Level = /* @__PURE__ */ ((Level2) => {
   Level2["Trace"] = "TRACE";
   Level2["Debug"] = "DEBUG";
@@ -10,118 +9,89 @@ var Level = /* @__PURE__ */ ((Level2) => {
   return Level2;
 })(Level || {});
 
-// src/main/getType.ts
-function getType(arg) {
-  if (typeof arg === "undefined") {
-    return "undefined";
-  }
-  if (typeof arg === "object" && String(arg) === "null") {
-    return "null";
-  }
-  if (Array.isArray(arg)) {
-    return "array";
-  }
-  if (ArrayBuffer.isView(arg)) {
-    return "typedarray";
-  }
-  if (arg instanceof ArrayBuffer) {
-    return "arraybuffer";
-  }
-  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 (arg instanceof Error) {
-    return "error";
-  }
-  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];
-  }
-  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])];
-      }
-    }
+    return [Level.Info, 0];
+  }
+  let s = level.toUpperCase().trim();
+  let data = s.split("+");
+  let major;
+  let minor;
+  if (data.length >= 2) {
+    major = data[0].trim() || Level.Info;
+    let n = Number(data[1].trim());
+    minor = Number.isFinite(n) ? Math.trunc(n) : 0;
+  } else {
+    major = s || Level.Info;
+    minor = 0;
+  }
+  if (minor < 0) minor = 0;
+  return [major, minor];
+}
+function printTimes(n, value) {
+  if (n <= 0) {
+    return "";
   }
-  return [data[0], Math.trunc(data[1]) || 0];
+  return value.repeat(n);
 }
 
-// src/main/errors.ts
-var HaluaFailedToCallHandler = class extends Error {
+function unknownToError(err) {
+  if (err instanceof Error) {
+    return err;
+  }
+  if (typeof err === "string") {
+    return new Error(err);
+  }
+  let error = "";
+  try {
+    error = JSON.stringify(err);
+  } catch (_) {
+  }
+  return new Error(error, { cause: err });
+}
+class HaluaFailedToCallDispatcher extends Error {
   constructor(message, options = {}) {
-    super(`HaluaFailedToCallHandlerError: ${message}`, options);
+    super(`HaluaFailedToCallDispatcherError: ${message}`, options);
   }
-};
-var HaluaUnableToDetermineHandler = class extends Error {
+}
+class HaluaUnableToDetermineDispatcher extends Error {
   constructor(message, options = {}) {
-    super(`HaluaUnableToDetermineHandlerError: ${message}`, options);
+    super(`HaluaUnableToDetermineDispatcherError: ${message}`, options);
   }
-};
-var HaluaParse = class extends Error {
+}
+class HaluaParse extends Error {
   constructor(message, options = {}) {
     super(`HaluaParseError: ${message}`, options);
   }
-};
+}
 
-// src/main/util/errors.ts
 function tryReportAnError(err) {
   try {
-    let log = "self" in window ? self.console : console;
+    let log = typeof self !== "undefined" ? 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 */])],
-  ["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 */])]
+const MajorLevelMap = /* @__PURE__ */ new Map([
+  [Level.Fatal, /* @__PURE__ */ new Set([Level.Fatal])],
+  [Level.Error, /* @__PURE__ */ new Set([Level.Fatal, Level.Error])],
+  [Level.Warn, /* @__PURE__ */ new Set([Level.Fatal, Level.Error, Level.Warn])],
+  [Level.Notice, /* @__PURE__ */ new Set([Level.Fatal, Level.Error, Level.Warn, Level.Notice])],
+  [Level.Info, /* @__PURE__ */ new Set([Level.Fatal, Level.Error, Level.Warn, Level.Notice, Level.Info])],
+  [Level.Debug, /* @__PURE__ */ new Set([Level.Fatal, Level.Error, Level.Warn, Level.Notice, Level.Info, Level.Debug])],
+  [Level.Trace, /* @__PURE__ */ new Set([Level.Fatal, Level.Error, Level.Warn, Level.Notice, Level.Info, Level.Debug, Level.Trace])]
 ]);
-var HandlersBalancer = class {
-  constructor(level, handlers, format2) {
+class DispatchersBalancer {
+  constructor(level, dispatchers) {
     this.level = level;
-    this.handlers = handlers;
-    this.format = format2;
+    this.dispatchers = dispatchers;
     this.sendLog = this.sendLog.bind(this);
-    this.reset = this.reset.bind(this);
   }
   map = /* @__PURE__ */ new Map();
-  sendLog(meta, args) {
+  sendLog(meta, args, errorMeta) {
     this.discover(meta.level);
-    this.send(meta, args);
-  }
-  reset() {
-    this.map.clear();
+    this.send(meta, args, errorMeta);
   }
   discover(level) {
     if (this.map.get(level)) {
@@ -129,7 +99,7 @@ var HandlersBalancer = class {
     }
     let discovered = [];
     this.map.set(level, discovered);
-    for (let h of this.handlers) {
+    for (let h of this.dispatchers) {
       if (h.exact) {
         if (h.exact.some((l) => l === level)) {
           discovered.push(h);
@@ -141,52 +111,202 @@ var HandlersBalancer = class {
       }
     }
   }
-  send(meta, args) {
+  send(meta, args, errorMeta) {
     try {
-      this.sendToHandlers(meta, args);
+      this.sendToDispatchers(meta, args, errorMeta);
     } catch (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 }));
-        }
-      });
+      tryReportAnError(
+        new HaluaFailedToCallDispatcher(`Unable to call dispatch method of a dispatcher`, { cause: e })
+      );
     }
-    generators.forEach((e, i) => {
-      e.next({ type: "done", value: null, prev: state[i] });
-    });
-    state = [];
   }
-  canSend(l, to = this.level || "TRACE" /* Trace */) {
+  sendToDispatchers(meta, args, errorMeta) {
+    let hs = this.map.get(meta.level) ?? [];
+    for (let h of hs) {
+      try {
+        h.dispatch(meta, args, errorMeta);
+      } catch (e) {
+        tryReportAnError(
+          new HaluaFailedToCallDispatcher(`Unable to call dispatch method of a dispatcher`, { cause: e })
+        );
+      }
+    }
+  }
+  canSend(l, to = this.level || Level.Trace) {
     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)) {
+    if (l === to) {
+      return 0;
+    }
+    let toSet = MajorLevelMap.get(to);
+    if (!toSet || !toSet.has(l)) {
       return -1;
     }
-    return l === to ? 0 : 1;
+    return 1;
   }
   minorLevelCheck(l, to) {
     return l >= to ? 1 : 0;
   }
-};
+}
+
+function toarray(value) {
+  return Array.isArray(value) ? value : typeof value === "undefined" ? [] : [value];
+}
+
+class Halua {
+  constructor(passed, options = {}) {
+    this.options = options;
+    this.passedDispatchers = passed;
+    this.dispatchers = this.buildDispatchers(passed);
+    this.balancer = new DispatchersBalancer(this.options.level || Level.Trace, this.dispatchers);
+    this.bindMethods();
+  }
+  passedDispatchers = [];
+  dispatchers = [];
+  balancer;
+  stamps = /* @__PURE__ */ new Map();
+  create(arg1 = this.passedDispatchers, arg2 = this.options) {
+    if (this.isDispatcherSpec(arg1)) {
+      return new Halua(arg1, { ...arg2 ?? this.options });
+    }
+    return new Halua(this.passedDispatchers, { ...arg1 });
+  }
+  child(...args) {
+    return new Halua(this.passedDispatchers, {
+      ...this.options,
+      withArgs: (this.options.withArgs || []).concat(args)
+    });
+  }
+  setDispatchers(dispatcher) {
+    this.dispatchers = this.buildDispatchers(dispatcher);
+    this.updateBalancer();
+  }
+  appendDispatchers(dispatcher) {
+    let dispatchers = this.buildDispatchers(dispatcher);
+    this.dispatchers.push(...dispatchers);
+    this.updateBalancer();
+  }
+  logTo(level, ...args) {
+    this.sendToBalancer(level, args);
+  }
+  trace(...args) {
+    this.sendToBalancer(Level.Trace, args);
+  }
+  debug(...args) {
+    this.sendToBalancer(Level.Debug, args);
+  }
+  info(...args) {
+    this.sendToBalancer(Level.Info, args);
+  }
+  warn(...args) {
+    this.sendToBalancer(Level.Warn, args);
+  }
+  notice(...args) {
+    this.sendToBalancer(Level.Notice, args);
+  }
+  error(error, meta) {
+    let e = unknownToError(error);
+    let payload = [e];
+    let finalMeta = meta != null ? { ...meta, error: e } : void 0;
+    this.sendToBalancer(Level.Error, payload, finalMeta);
+  }
+  fatal(...args) {
+    this.sendToBalancer(Level.Fatal, args);
+  }
+  assert(assertion, error, meta) {
+    if (assertion) {
+      return;
+    }
+    let e = unknownToError(error);
+    let payload = [e];
+    let finalMeta = meta != null ? { ...meta, error: e } : void 0;
+    this.sendToBalancer(Level.Error, payload, finalMeta);
+  }
+  stamp(label, id) {
+    let start = performance.now();
+    if (id != null) {
+      this.stamps.set(id, { label, start });
+    }
+    let ended = false;
+    const ender = () => {
+      if (ended) {
+        return;
+      }
+      ended = true;
+      if (id != null) {
+        let current = this.stamps.get(id);
+        if (current && current.start === start) {
+          this.stamps.delete(id);
+        }
+      }
+      this.endStamp(label, start);
+    };
+    return ender;
+  }
+  stampEnd(id) {
+    let entry = this.stamps.get(id);
+    if (!entry) {
+      return;
+    }
+    this.stamps.delete(id);
+    this.endStamp(entry.label, entry.start);
+  }
+  endStamp(label, start) {
+    let duration = performance.now() - start;
+    let ms = duration.toFixed(2);
+    this.info(label, `took ${ms}ms`);
+  }
+  updateBalancer() {
+    this.balancer = new DispatchersBalancer(this.options.level || Level.Trace, this.dispatchers);
+  }
+  sendToBalancer(level, args, errorMeta) {
+    let finalArgs = args.concat(this.options.withArgs ?? []);
+    let dispatchMeta = { level, timestamp: Date.now() };
+    if (this.options.redactDataRegExp) {
+      dispatchMeta.redactDataRegExp = this.options.redactDataRegExp;
+    }
+    this.balancer.sendLog(dispatchMeta, finalArgs, errorMeta);
+  }
+  supposeIsDispatcher(v, reportError = true) {
+    let isDispatcher = typeof v?.dispatch === "function";
+    if (!isDispatcher && reportError) {
+      tryReportAnError(new HaluaUnableToDetermineDispatcher(`Unable to find dispatch method of a dispatcher`));
+    }
+    return isDispatcher;
+  }
+  isDispatcherSpec(v) {
+    if (Array.isArray(v)) {
+      return v.every((x) => typeof x === "function");
+    }
+    return typeof v === "function";
+  }
+  buildDispatchers(passed) {
+    let entries = toarray(passed);
+    return entries.map((b) => b()).filter((h) => this.supposeIsDispatcher(h));
+  }
+  bindMethods() {
+    this.create = this.create.bind(this);
+    this.child = this.child.bind(this);
+    this.setDispatchers = this.setDispatchers.bind(this);
+    this.appendDispatchers = this.appendDispatchers.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.stamp = this.stamp.bind(this);
+    this.stampEnd = this.stampEnd.bind(this);
+    this.supposeIsDispatcher = this.supposeIsDispatcher.bind(this);
+  }
+}
 
-// src/util/spacing.ts
 var Spacing = /* @__PURE__ */ ((Spacing2) => {
   Spacing2["Space"] = " ";
   Spacing2["Tab"] = "	";
@@ -202,17 +322,50 @@ var EmptySpacing = /* @__PURE__ */ ((EmptySpacing2) => {
   return EmptySpacing2;
 })(EmptySpacing || {});
 
-// src/util/string.ts
-function printTimes(n, value) {
-  let str = "";
-  for (let i = n; i !== 0; i -= 1) {
-    str += value;
+function getType(arg) {
+  if (typeof arg === "undefined") {
+    return "undefined";
+  }
+  if (typeof arg === "object" && String(arg) === "null") {
+    return "null";
+  }
+  if (Array.isArray(arg)) {
+    return "array";
+  }
+  if (ArrayBuffer.isView(arg)) {
+    return "typedarray";
+  }
+  if (arg instanceof ArrayBuffer) {
+    return "arraybuffer";
+  }
+  if (arg instanceof Map) {
+    return "map";
+  }
+  if (arg instanceof Set) {
+    return "set";
+  }
+  if (arg instanceof WeakMap) {
+    return "weakmap";
   }
-  return str;
+  if (arg instanceof WeakSet) {
+    return "weakset";
+  }
+  if (arg instanceof Date) {
+    return "date";
+  }
+  if (arg instanceof Error) {
+    return "error";
+  }
+  if (Number.isNaN(arg)) {
+    return "nan";
+  }
+  if (typeof arg === "number" && !Number.isFinite(arg)) {
+    return "infinity";
+  }
+  return typeof arg;
 }
 
-// src/main/format.ts
-var FormatAsIs = [
+const FormatAsIs = [
   "undefined",
   "null",
   "string",
@@ -225,7 +378,7 @@ var FormatAsIs = [
   "nan",
   "infinity"
 ];
-var FormatNeeded = [
+const FormatNeeded = [
   "array",
   "object",
   "arraybuffer",
@@ -238,24 +391,19 @@ var FormatNeeded = [
 ];
 function format(arg, spacing = true) {
   try {
-    const SpacingEnum = spacing ? Spacing : EmptySpacing;
+    let SpacingEnum = spacing ? Spacing : EmptySpacing;
+    let seen = /* @__PURE__ */ new WeakSet();
     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);
+      return formatComplex(arg.value, arg.type, SpacingEnum, 1, seen);
     }
   } 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;
@@ -265,9 +413,25 @@ function formatAsIs(arg, type) {
   }
   return String(arg);
 }
-function formatComplex(arg, type, spacing, nestingLevel = 1) {
+function formatValue(value, spacing, seen) {
+  let type = getType(value);
+  if (FormatAsIs.some((f) => f === type)) {
+    return formatAsIs(value, type);
+  }
+  if (FormatNeeded.some((f) => f === type)) {
+    return formatComplex(value, type, spacing, 1, seen);
+  }
+  return value;
+}
+function formatComplex(arg, type, spacing, nestingLevel = 1, seen) {
   if (type === "set") {
-    return `Set${formatArray(convertSetToArray(arg), spacing)}`;
+    if (seen.has(arg)) {
+      return "[Circular]";
+    }
+    seen.add(arg);
+    let r = `Set${formatArray(convertSetToArray(arg), spacing, seen)}`;
+    seen.delete(arg);
+    return r;
   }
   if (type === "weakset") {
     return `WeakSet [inaccessible]`;
@@ -280,59 +444,72 @@ function formatComplex(arg, type, spacing, nestingLevel = 1) {
     return `Function ${name === "value" ? "anonymous" : name}`;
   }
   if (type === "array") {
-    return formatArray(arg, spacing);
+    if (seen.has(arg)) {
+      return "[Circular]";
+    }
+    seen.add(arg);
+    let r = formatArray(arg, spacing, seen);
+    seen.delete(arg);
+    return r;
   }
   if (type === "arraybuffer") {
     return `ArrayBuffer []`;
   }
   if (type === "map") {
-    return formatObject(convertMapToObj(arg), spacing, nestingLevel, ` => `);
+    if (seen.has(arg)) {
+      return "[Circular]";
+    }
+    seen.add(arg);
+    let r = formatObject(convertMapToObj(arg, spacing, seen), spacing, nestingLevel, ` => `, seen);
+    seen.delete(arg);
+    return r;
   }
   if (type === "error") {
     return `${arg.toString()} stack: ${arg.stack}`;
   }
   if (type === "object") {
-    return formatObject(arg, spacing, nestingLevel);
+    if (seen.has(arg)) {
+      return "[Circular]";
+    }
+    seen.add(arg);
+    let r = formatObject(arg, spacing, nestingLevel, `: `, seen);
+    seen.delete(arg);
+    return r;
   }
   return arg;
 }
-function formatArray(arg, spacing) {
-  let stringify = "[";
-  let len = arg.length;
+function formatArray(arg, spacing, seen) {
+  let items = [];
   for (let entry of arg) {
-    len -= 1;
     let entryType = getType(entry);
-    let formatted = format({ type: entryType, value: entry });
+    let formatted = formatValue(entry, spacing, seen);
     let entryValue = entryType === "string" ? `"${formatted}"` : formatted;
-    stringify += `${entryValue}${len ? `,${spacing.Space}` : spacing.Empty}`;
+    items.push(entryValue);
   }
-  stringify += "]";
-  return stringify;
+  let sep = `,${spacing.Space}`;
+  return `[${items.join(sep)}]`;
 }
-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]
-    });
+function formatObject(arg, spacing, nestingLevel = 1, delimiter = `: `, seen) {
+  let keys = Object.keys(arg);
+  let kvParts = [];
+  for (let key of keys) {
+    let val = arg[key];
+    let entryType = getType(val);
+    let formatted = entryType === "object" ? formatComplex(val, entryType, spacing, nestingLevel + 1, seen) : formatValue(val, spacing, seen);
     let entryValue = entryType === "string" ? `"${formatted}"` : formatted;
-    stringify += `${printTimes(nestingLevel, spacing.Tab)}"${key}"${delimiter}${entryValue}${len ? `,${spacing.Line}` : spacing.Empty}`;
+    kvParts.push(`${printTimes(nestingLevel, spacing.Tab)}"${key}"${delimiter}${entryValue}`);
   }
+  let body = kvParts.join(`,${spacing.Line}`);
   let level = nestingLevel - 1;
-  stringify += `${spacing.Line}${printTimes(level, spacing.Tab)}}`;
-  return stringify;
+  let closeIndent = printTimes(level, spacing.Tab);
+  return `{${spacing.Line}${kvParts.length ? body + spacing.Line : ""}${closeIndent}}`;
 }
-function convertMapToObj(value) {
+function convertMapToObj(value, spacing, seen) {
   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 });
+    let objKey = keyType === "string" ? key : formatValue(key, spacing, seen);
+    obj[objKey] = formatValue(v, spacing, seen);
   }
   return obj;
 }
@@ -343,182 +520,300 @@ function convertSetToArray(value) {
   }
   return arr;
 }
-
-// src/main/util/cast.ts
-function toarray(value) {
-  return Array.isArray(value) ? value : typeof value === "undefined" ? [] : [value];
+function toJSONValue(value) {
+  return convertToJSONValue(value, /* @__PURE__ */ new WeakSet());
 }
-
-// src/main/halua.ts
-var Halua = class _Halua {
-  constructor(passed, options = {}) {
-    this.options = options;
-    this.passedHandlers = passed;
-    this.handlers = this.buildHandlers(passed);
-    this.balancer = new HandlersBalancer(this.options.level || "TRACE" /* Trace */, this.handlers, format);
-    this.bindMethods();
+function convertToJSONValue(value, seen) {
+  if (value == null) {
+    return null;
   }
-  passedHandlers = [];
-  handlers = [];
-  balancer;
-  create(arg1 = this.passedHandlers, arg2 = this.options) {
-    if (Array.isArray(arg1)) {
-      return new _Halua(arg1, { ...arg2 });
-    }
-    if (this.supposeIsHandler(arg1, false)) {
-      return new _Halua(arg1, { ...arg2 });
-    }
-    if (Object.keys(arg1).length) {
-      return new _Halua(this.passedHandlers, { ...arg1 });
-    }
-    return new _Halua(arg1, { ...arg2 });
+  let type = getType(value);
+  if (type === "boolean" || type === "number" || type === "string") {
+    return value;
   }
-  child(...args) {
-    return new _Halua(this.passedHandlers, { ...this.options, withArgs: (this.options.withArgs || []).concat(args) });
+  if (type === "symbol" || type === "function" || type === "bigint") {
+    return value.toString();
   }
-  setHandlers(handler) {
-    this.handlers = this.buildHandlers(handler);
-    this.updateBalancer();
+  if (type === "date") {
+    return value.toISOString();
   }
-  appendHandlers(handler) {
-    let handlers = this.buildHandlers(handler);
-    this.handlers.push(...handlers);
-    this.updateBalancer();
+  if (type === "nan" || type === "infinity") {
+    return String(value);
   }
-  logTo(level, ...args) {
-    this.sendToBalancer(level, args);
+  if (type === "error") {
+    let stack = value.stack ? value.stack.split(/\r?\n/) : [];
+    return { name: value.name || "Error", message: value.message || "", stack };
   }
-  trace(...args) {
-    this.sendToBalancer("TRACE" /* Trace */, args);
+  if (type === "weakmap" || type === "weakset") {
+    return `[${type} inaccessible]`;
   }
-  debug(...args) {
-    this.sendToBalancer("DEBUG" /* Debug */, args);
+  if (type === "arraybuffer") {
+    return { __type: "ArrayBuffer", byteLength: value.byteLength };
   }
-  info(...args) {
-    this.sendToBalancer("INFO" /* Info */, args);
+  if (type === "typedarray") {
+    return Array.from(value);
   }
-  warn(...args) {
-    this.sendToBalancer("WARN" /* Warn */, args);
+  if (type === "array" || type === "object" || type === "map" || type === "set") {
+    if (seen.has(value)) {
+      return { __circular: true };
+    }
+    seen.add(value);
+    let result;
+    if (type === "array") {
+      result = value.map((item) => convertToJSONValue(item, seen));
+    } else if (type === "object") {
+      result = {};
+      for (let key of Object.keys(value)) {
+        result[key] = convertToJSONValue(value[key], seen);
+      }
+    } else if (type === "map") {
+      result = {};
+      for (let [k, v] of value) {
+        let jk = convertToJSONValue(k, seen);
+        let keyStr = typeof jk === "string" ? jk : String(jk ?? "");
+        result[keyStr] = convertToJSONValue(v, seen);
+      }
+    } else if (type === "set") {
+      result = Array.from(value, (item) => convertToJSONValue(item, seen));
+    }
+    seen.delete(value);
+    return result;
   }
-  notice(...args) {
-    this.sendToBalancer("NOTICE" /* Notice */, args);
+  return String(value);
+}
+const REDACTION_TOKEN = "^_^";
+const DefaultRedactRegExp = /pass(?:word|wd)?|secret|token|api[_-]?key|access[_-]?token|auth(?:orization)?|private[_-]?key|credential|session(?:[_-]?id)?|cookie|ssn|social[_-]?sec(?:urity)?|credit[_-]?card|cc[_-]?num(?:ber)?|cvv|cvc|pin|email|phone|mobile|tel|bearer|eyJ[0-9a-zA-Z_-]{10,}\.[0-9a-zA-Z_-]{10,}|\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b|\b\d{3}[-.\s]?\d{2}[-.\s]?\d{4}\b|\b(?:\d[ -]*){13,16}\b/i;
+function redact(value, regexp) {
+  if (!regexp) {
+    return value;
   }
-  error(...args) {
-    this.sendToBalancer("ERROR" /* Error */, args);
+  return redactRec(value, regexp, /* @__PURE__ */ new WeakSet());
+}
+function redactRec(value, re, seen) {
+  if (value == null) {
+    return value;
   }
-  fatal(...args) {
-    this.sendToBalancer("FATAL" /* Fatal */, args);
+  let type = getType(value);
+  if (type === "string") {
+    return redactString(value, re);
   }
-  assert(assertion, ...args) {
-    if (assertion) {
-      return;
+  if (type === "array") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    let result = [];
+    for (let entry of value) {
+      result.push(redactRec(entry, re, seen));
     }
-    this.sendToBalancer("ERROR" /* Error */, args);
+    seen.delete(value);
+    return result;
   }
-  updateBalancer() {
-    this.balancer = new HandlersBalancer(this.options.level || "TRACE" /* Trace */, this.handlers, format);
+  if (type === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    let result = {};
+    for (let key of Object.keys(value)) {
+      let k = key;
+      re.lastIndex = 0;
+      if (re.test(k)) {
+        result[k] = REDACTION_TOKEN;
+      } else {
+        result[k] = redactRec(value[k], re, seen);
+      }
+    }
+    seen.delete(value);
+    return result;
   }
-  sendToBalancer(level, args) {
-    this.balancer.sendLog({ level, timestamp: Date.now() }, args.concat(this.options.withArgs ?? []));
+  if (type === "map") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    let result = /* @__PURE__ */ new Map();
+    for (let [k, v] of value) {
+      let keyStr = typeof k === "string" ? k : String(k ?? "");
+      re.lastIndex = 0;
+      if (re.test(keyStr)) {
+        result.set(k, REDACTION_TOKEN);
+      } else {
+        result.set(k, redactRec(v, re, seen));
+      }
+    }
+    seen.delete(value);
+    return result;
   }
-  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`));
+  if (type === "set") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    let result = /* @__PURE__ */ new Set();
+    for (let item of value) {
+      result.add(redactRec(item, re, seen));
     }
-    return isHandler;
+    seen.delete(value);
+    return result;
   }
-  buildHandlers(passed) {
-    let entries = toarray(passed);
-    return entries.map((b) => b()).filter((h) => this.supposeIsHandler(h));
+  if (type === "error") {
+    let msg = value.message;
+    if (typeof msg === "string") {
+      msg = redactString(msg, re);
+    }
+    let Ctor = value.constructor || Error;
+    let redacted;
+    try {
+      redacted = new Ctor(msg);
+      if (value.name) {
+        redacted.name = value.name;
+      }
+      if (value.stack) {
+        redacted.stack = value.stack;
+      }
+    } catch (_) {
+      redacted = value;
+    }
+    return redacted;
   }
-  bindMethods() {
-    this.create = this.create.bind(this);
-    this.child = this.child.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);
+  return value;
+}
+function redactString(str, re) {
+  if (!re || typeof str !== "string") {
+    return str;
   }
-};
+  let flags = re.flags || "";
+  if (!flags.includes("g")) {
+    flags = flags + "g";
+  }
+  let searchRe;
+  try {
+    searchRe = new RegExp(re.source, flags);
+  } catch (_) {
+    return str;
+  }
+  searchRe.lastIndex = 0;
+  let result = "";
+  let last = 0;
+  let match;
+  while ((match = searchRe.exec(str)) !== null) {
+    let matchEnd = searchRe.lastIndex;
+    let replacement = REDACTION_TOKEN;
+    let newLast = matchEnd;
+    let tail = str.slice(matchEnd);
+    let assign = tail.match(/^(\s*[=:]\s*)(".*?"|'.*?'|\S+)?/);
+    if (assign) {
+      newLast = matchEnd + assign[0].length;
+      replacement = REDACTION_TOKEN;
+      searchRe.lastIndex = newLast;
+    }
+    result += str.slice(last, match.index) + replacement;
+    last = newLast;
+  }
+  result += str.slice(last);
+  return result;
+}
 
-// src/main/handlers/HandlerBase.ts
-var HandlerBase = class {
+class DispatcherBase {
   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" };
+  redactDataRegExp;
+  _lastTimestampSec = -1;
+  _lastTimestampStr = "";
+  constructor(send = () => {
+  }, options = {}) {
+    this.dispatch = this.dispatch.bind(this);
+    this.sendMethod = send;
+    this.printTimestamp = options.printTimestamp ?? true;
+    this.printLevel = options.printLevel ?? true;
+    this.level = options.level;
+    this.exact = options.exact ? toarray(options.exact) : null;
+    this.redactDataRegExp = options.redactDataRegExp;
+  }
+  dispatch(meta, args, errorMeta) {
+    let effectiveRe = this.redactDataRegExp || meta.redactDataRegExp;
+    let processedArgs = effectiveRe ? args.map((v) => redact(v, effectiveRe)) : args;
+    let processedErrorMeta = errorMeta;
+    if (effectiveRe && errorMeta != null) {
+      processedErrorMeta = redact(errorMeta, effectiveRe);
+    }
+    let parts = [];
     if (this.printTimestamp) {
-      arg += `${this.formatTimestamp(meta.timestamp)}`;
+      parts.push(this.formatTimestamp(meta.timestamp));
     }
     if (this.printLevel) {
-      arg += `  ${meta.level}`;
+      parts.push(meta.level);
     }
-    while (true) {
-      if (current.type === "init") {
-        current = yield { type: "init" };
-      }
-      if (current.prev) {
-        arg += " " + current.prev;
-      }
-      if (current.type === "done") {
-        break;
-      }
-      if (current.type === "arg") {
-        if (typeof this.formatArg === "function") {
-          arg += " " + this.formatArg(current.value);
-          current = yield { type: "done" };
-          continue;
-        }
+    for (let value of processedArgs) {
+      let formatted;
+      if (typeof this.formatArg === "function") {
+        formatted = this.formatArg(value);
+      } else {
+        formatted = value;
       }
-      current = yield { type: "pass" };
+      parts.push(formatted);
     }
-    this.sendMethod(arg.trimStart());
+    this.sendMethod(parts.join(" "), processedErrorMeta);
   }
   formatTimestamp(t) {
+    let sec = Math.floor(t / 1e3);
+    if (sec === this._lastTimestampSec) {
+      return this._lastTimestampStr;
+    }
     let d = new Date(t);
-    return `${d.toLocaleDateString()} ${d.toLocaleTimeString()}`;
+    let s = `${d.toLocaleDateString()} ${d.toLocaleTimeString()}`;
+    this._lastTimestampSec = sec;
+    this._lastTimestampStr = s;
+    return s;
   }
-};
+}
 
-// 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;
-    }
-    level;
-    exact = null;
-    formatArg = (arg) => arg;
-    applyOptionalOptions(options2) {
-      this.printTimestamp = options2.printTimestamp ?? true;
-      this.printLevel = options2.printLevel ?? true;
-    }
-    *execute(meta) {
+function prepareDispatchArgs(redactDataRegExp, meta, rawArgs, errorMeta) {
+  let effectiveRe = redactDataRegExp || meta.redactDataRegExp;
+  let processedRawArgs = effectiveRe ? rawArgs.map((v) => redact(v, effectiveRe)) : rawArgs;
+  let processedErrorMeta = errorMeta;
+  if (effectiveRe && errorMeta != null) {
+    processedErrorMeta = redact(errorMeta, effectiveRe);
+  }
+  return { processedRawArgs, processedErrorMeta };
+}
+function routeConsoleCall(target, level, args) {
+  let ul = level.toUpperCase();
+  if (ul.startsWith("DEBUG")) {
+    target.debug(...args);
+    return;
+  }
+  if (ul.startsWith("WARN")) {
+    target.warn(...args);
+    return;
+  }
+  if (ul.startsWith("ERROR") || ul.startsWith("FATAL")) {
+    target.error(...args);
+    return;
+  }
+  target.info(...args);
+}
+
+function NewConsoleDispatcher(console, options) {
+  return () => new class ConsoleDispatcher extends DispatcherBase {
+    constructor(console2, options2 = {}) {
+      super(() => {
+      }, options2);
+      this.console = console2;
+    }
+    dispatch(meta, rawArgs, errorMeta) {
+      let { processedRawArgs, processedErrorMeta } = prepareDispatchArgs(
+        this.redactDataRegExp,
+        meta,
+        rawArgs,
+        errorMeta
+      );
       let args = [];
-      let current = { value: null, type: "init" };
       if (this.printTimestamp) {
         args.push(`${this.formatTimestamp(meta.timestamp)}`);
       }
@@ -526,137 +821,178 @@ function NewConsoleHandler(console2, options) {
         let margin = this.printTimestamp ? " " : "";
         args.push(`${margin}${meta.level}`);
       }
-      while (true) {
-        if (current.type === "init") {
-          current = yield { type: "init" };
+      for (let value of processedRawArgs) {
+        let formatted;
+        if (typeof this.formatArg === "function") {
+          formatted = this.formatArg(value);
+        } else {
+          formatted = value;
         }
-        if (current.prev) {
-          args.push(current.prev);
+        args.push(formatted);
+      }
+      if (processedErrorMeta !== void 0) {
+        let m = typeof this.formatArg === "function" ? this.formatArg(processedErrorMeta) : processedErrorMeta;
+        args.push(m);
+      }
+      routeConsoleCall(this.console, meta.level, args);
+    }
+  }(console, options);
+}
+
+const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+const ANSI = {
+  purple: "\x1B[35m",
+  blue: "\x1B[34m",
+  orange: "\x1B[38;5;208m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m"
+};
+const CSS = {
+  purple: "color:#a855f7;font-weight:bold",
+  blue: "color:#3b82f6;font-weight:bold",
+  orange: "color:#f97316;font-weight:bold",
+  red: "color:#ef4444;font-weight:bold"
+};
+const getColorForLevel = (level) => {
+  let l = level.toUpperCase();
+  if (l.startsWith("TRACE") || l.startsWith("DEBUG")) {
+    return "purple";
+  }
+  if (l.startsWith("INFO")) {
+    return "blue";
+  }
+  if (l.startsWith("NOTICE")) {
+    return "orange";
+  }
+  if (l.startsWith("WARN") || l.startsWith("ERROR") || l.startsWith("FATAL")) {
+    return "red";
+  }
+  return "blue";
+};
+function NewConsoleColoredDispatcher(console, options) {
+  return () => new class ConsoleColoredDispatcher extends DispatcherBase {
+    constructor(console2, options2 = {}) {
+      super(() => {
+      }, options2);
+      this.console = console2;
+    }
+    dispatch(meta, rawArgs, errorMeta) {
+      let { processedRawArgs, processedErrorMeta } = prepareDispatchArgs(
+        this.redactDataRegExp,
+        meta,
+        rawArgs,
+        errorMeta
+      );
+      let colorKey = getColorForLevel(meta.level);
+      if (isNode) {
+        let args = [];
+        if (this.printTimestamp) {
+          args.push(`${this.formatTimestamp(meta.timestamp)}`);
         }
-        if (current.type === "done") {
-          break;
+        if (this.printLevel) {
+          let margin = this.printTimestamp ? " " : "";
+          let c = ANSI[colorKey];
+          let r = ANSI.reset;
+          args.push(`${margin}${c}${meta.level}${r}`);
         }
-        if (current.type === "arg") {
+        for (let value of processedRawArgs) {
+          let formatted;
           if (typeof this.formatArg === "function") {
-            args.push(current.value);
-            current = yield { type: "done" };
-            continue;
+            formatted = this.formatArg(value);
+          } else {
+            formatted = value;
           }
+          args.push(formatted);
         }
-        current = yield { type: "pass" };
-      }
-      if (meta.level.startsWith("DEBUG")) {
-        this.console.debug(...args);
+        if (processedErrorMeta !== void 0) {
+          let m = typeof this.formatArg === "function" ? this.formatArg(processedErrorMeta) : processedErrorMeta;
+          args.push(m);
+        }
+        routeConsoleCall(this.console, meta.level, args);
         return;
       }
-      if (meta.level.startsWith("WARN")) {
-        this.console.warn(...args);
-        return;
+      let cargs;
+      if (!this.printTimestamp && !this.printLevel) {
+        cargs = [];
+      } else {
+        let formatStr = "";
+        let styleArgs = [];
+        if (this.printTimestamp) {
+          formatStr += "%s";
+          styleArgs.push(`${this.formatTimestamp(meta.timestamp)}`);
+        }
+        if (this.printLevel) {
+          let css = CSS[colorKey];
+          if (formatStr) {
+            formatStr += " ";
+          }
+          formatStr += "%c%s%c";
+          styleArgs.push(css, meta.level, "");
+        }
+        cargs = [formatStr, ...styleArgs];
       }
-      if (meta.level.startsWith("ERROR") || meta.level.startsWith("FATAL")) {
-        this.console.error(...args);
-        return;
+      for (let value of processedRawArgs) {
+        let formatted;
+        if (typeof this.formatArg === "function") {
+          formatted = this.formatArg(value);
+        } else {
+          formatted = value;
+        }
+        cargs.push(formatted);
       }
-      this.console.info(...args);
+      if (processedErrorMeta !== void 0) {
+        let m = typeof this.formatArg === "function" ? this.formatArg(processedErrorMeta) : processedErrorMeta;
+        cargs.push(m);
+      }
+      routeConsoleCall(this.console, meta.level, cargs);
     }
-  }(console2, options);
+  }(console, options);
 }
 
-// src/main/handlers/JSONHandler.ts
-function NewJSONHandler(send, options) {
-  return () => new class JSONHandler extends HandlerBase {
-    level;
-    exact = null;
+function NewJSONDispatcher(send, options) {
+  return () => new class JSONDispatcher extends DispatcherBase {
     constructor(send2, options2 = {}) {
-      super(send2);
-      this.applyOptionalOptions(options2);
-      this.level = options2.level;
-      this.exact = options2.exact ? toarray(options2.exact) : null;
-    }
-    formatArg = (arg) => {
-      let type = getType(arg);
-      let formatted = formatJSON({ type, value: arg });
-      if (type !== "object" && type !== "map") {
-        return `"${formatted}"`;
-      }
-      return formatted;
-    };
-    *execute(meta) {
-      let arg = "{";
-      let current = { value: null, type: "init" };
+      super(send2, options2);
+    }
+    dispatch(meta, rawArgs, errorMeta) {
+      let { processedRawArgs, processedErrorMeta } = prepareDispatchArgs(
+        this.redactDataRegExp,
+        meta,
+        rawArgs,
+        errorMeta
+      );
+      let obj = {};
       if (this.printTimestamp) {
-        arg += `"timestamp":"${this.formatTimestamp(meta.timestamp)}",`;
+        obj.timestamp = this.formatTimestamp(meta.timestamp);
       }
       if (this.printLevel) {
-        arg += `"level":"${meta.level}",`;
-      }
-      arg += `"args":[`;
-      while (true) {
-        if (current.type === "init") {
-          current = yield { type: "init" };
-        }
-        if (current.prev) {
-          arg += `"${current.prev}",`;
-        }
-        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);
+        obj.level = meta.level;
       }
-      arg += `]}`;
-      this.sendMethod(arg);
+      obj.args = processedRawArgs.map((a) => toJSONValue(a));
+      this.sendMethod(JSON.stringify(obj), processedErrorMeta);
     }
     formatTimestamp(t) {
       return new Date(t).toISOString();
     }
-    applyOptionalOptions(options2) {
-      this.printTimestamp = options2.printTimestamp ?? true;
-      this.printLevel = options2.printLevel ?? true;
-    }
   }(send, options);
 }
 
-// src/main/handlers/TextHandler.ts
-function NewTextHandler(send, options) {
-  return () => new class TextHandler extends HandlerBase {
-    level;
-    exact = null;
-    formatArg;
+function NewTextDispatcher(send, options) {
+  return () => new class TextDispatcher extends DispatcherBase {
     constructor(send2, options2 = {}) {
-      super(send2);
-      this.applyOptionalOptions(options2);
-      this.level = options2.level;
-      this.exact = options2.exact ? toarray(options2.exact) : null;
+      super(send2, options2);
       this.formatArg = (value) => format({ type: getType(value), value }, options2.spacing);
     }
-    applyOptionalOptions(options2) {
-      this.printTimestamp = options2.printTimestamp ?? true;
-      this.printLevel = options2.printLevel ?? true;
-    }
   }(send, options);
 }
 
-// src/index.ts
-var logConsole = null;
-try {
-  logConsole = typeof self !== "undefined" ? self.console : console;
-} catch (_) {
-}
-var halua = new Halua(logConsole ? NewConsoleHandler(logConsole) : []);
-export {
-  Level,
-  NewConsoleHandler,
-  NewJSONHandler,
-  NewTextHandler,
-  halua
-};
+const logConsole = (() => {
+  try {
+    return typeof self !== "undefined" ? self.console : console;
+  } catch (_) {
+    return null;
+  }
+})();
+const halua = new Halua(logConsole ? NewConsoleDispatcher(logConsole) : []);
+
+export { DefaultRedactRegExp, DispatcherBase, Level, NewConsoleColoredDispatcher, NewConsoleDispatcher, NewJSONDispatcher, NewTextDispatcher, format, getType, halua, redact, toJSONValue };