apitally 0.21.1 → 0.21.2

package/dist/adonisjs/provider.cjs

@@ -440,619 +440,458 @@ var require_caller = __commonJS({
   }
 });
 
-// node_modules/fast-redact/lib/validator.js
-var require_validator = __commonJS({
-  "node_modules/fast-redact/lib/validator.js"(exports2, module2) {
+// node_modules/@pinojs/redact/index.js
+var require_redact = __commonJS({
+  "node_modules/@pinojs/redact/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = validator;
-    function validator(opts = {}) {
-      const { ERR_PATHS_MUST_BE_STRINGS = /* @__PURE__ */ __name(() => "fast-redact - Paths must be (non-empty) strings", "ERR_PATHS_MUST_BE_STRINGS"), ERR_INVALID_PATH = /* @__PURE__ */ __name((s) => `fast-redact \u2013 Invalid path (${s})`, "ERR_INVALID_PATH") } = opts;
-      return /* @__PURE__ */ __name(function validate({ paths }) {
-        paths.forEach((s) => {
-          if (typeof s !== "string") {
-            throw Error(ERR_PATHS_MUST_BE_STRINGS());
+    function deepClone(obj) {
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      if (obj instanceof Date) {
+        return new Date(obj.getTime());
+      }
+      if (obj instanceof Array) {
+        const cloned = [];
+        for (let i = 0; i < obj.length; i++) {
+          cloned[i] = deepClone(obj[i]);
+        }
+        return cloned;
+      }
+      if (typeof obj === "object") {
+        const cloned = Object.create(Object.getPrototypeOf(obj));
+        for (const key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            cloned[key] = deepClone(obj[key]);
           }
-          try {
-            if (/〇/.test(s)) throw Error();
-            const expr = (s[0] === "[" ? "" : ".") + s.replace(/^\*/, "\u3007").replace(/\.\*/g, ".\u3007").replace(/\[\*\]/g, "[\u3007]");
-            if (/\n|\r|;/.test(expr)) throw Error();
-            if (/\/\*/.test(expr)) throw Error();
-            Function(`
-            'use strict'
-            const o = new Proxy({}, { get: () => o, set: () => { throw Error() } });
-            const \u3007 = null;
-            o${expr}
-            if ([o${expr}].length !== 1) throw Error()`)();
-          } catch (e) {
-            throw Error(ERR_INVALID_PATH(s));
+        }
+        return cloned;
+      }
+      return obj;
+    }
+    __name(deepClone, "deepClone");
+    function parsePath(path) {
+      const parts = [];
+      let current = "";
+      let inBrackets = false;
+      let inQuotes = false;
+      let quoteChar = "";
+      for (let i = 0; i < path.length; i++) {
+        const char = path[i];
+        if (!inBrackets && char === ".") {
+          if (current) {
+            parts.push(current);
+            current = "";
+          }
+        } else if (char === "[") {
+          if (current) {
+            parts.push(current);
+            current = "";
+          }
+          inBrackets = true;
+        } else if (char === "]" && inBrackets) {
+          parts.push(current);
+          current = "";
+          inBrackets = false;
+          inQuotes = false;
+        } else if ((char === '"' || char === "'") && inBrackets) {
+          if (!inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+          } else if (char === quoteChar) {
+            inQuotes = false;
+            quoteChar = "";
+          } else {
+            current += char;
           }
-        });
-      }, "validate");
-    }
-    __name(validator, "validator");
-  }
-});
-
-// node_modules/fast-redact/lib/rx.js
-var require_rx = __commonJS({
-  "node_modules/fast-redact/lib/rx.js"(exports2, module2) {
-    "use strict";
-    module2.exports = /[^.[\]]+|\[((?:.)*?)\]/g;
-  }
-});
-
-// node_modules/fast-redact/lib/parse.js
-var require_parse = __commonJS({
-  "node_modules/fast-redact/lib/parse.js"(exports2, module2) {
-    "use strict";
-    var rx = require_rx();
-    module2.exports = parse;
-    function parse({ paths }) {
-      const wildcards = [];
-      var wcLen = 0;
-      const secret = paths.reduce(function(o, strPath, ix) {
-        var path = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
-        const leadingBracket = strPath[0] === "[";
-        path = path.map((p) => {
-          if (p[0] === "[") return p.substr(1, p.length - 2);
-          else return p;
-        });
-        const star = path.indexOf("*");
-        if (star > -1) {
-          const before = path.slice(0, star);
-          const beforeStr = before.join(".");
-          const after = path.slice(star + 1, path.length);
-          const nested = after.length > 0;
-          wcLen++;
-          wildcards.push({
-            before,
-            beforeStr,
-            after,
-            nested
-          });
         } else {
-          o[strPath] = {
-            path,
-            val: void 0,
-            precensored: false,
-            circle: "",
-            escPath: JSON.stringify(strPath),
-            leadingBracket
-          };
+          current += char;
         }
-        return o;
-      }, {});
-      return {
-        wildcards,
-        wcLen,
-        secret
-      };
+      }
+      if (current) {
+        parts.push(current);
+      }
+      return parts;
     }
-    __name(parse, "parse");
-  }
-});
-
-// node_modules/fast-redact/lib/redactor.js
-var require_redactor = __commonJS({
-  "node_modules/fast-redact/lib/redactor.js"(exports2, module2) {
-    "use strict";
-    var rx = require_rx();
-    module2.exports = redactor;
-    function redactor({ secret, serialize, wcLen, strict, isCensorFct, censorFctTakesPath }, state) {
-      const redact = Function("o", `
-    if (typeof o !== 'object' || o == null) {
-      ${strictImpl(strict, serialize)}
-    }
-    const { censor, secret } = this
-    const originalSecret = {}
-    const secretKeys = Object.keys(secret)
-    for (var i = 0; i < secretKeys.length; i++) {
-      originalSecret[secretKeys[i]] = secret[secretKeys[i]]
+    __name(parsePath, "parsePath");
+    function setValue(obj, parts, value) {
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (typeof current !== "object" || current === null || !(key in current)) {
+          return false;
+        }
+        if (typeof current[key] !== "object" || current[key] === null) {
+          return false;
+        }
+        current = current[key];
+      }
+      const lastKey = parts[parts.length - 1];
+      if (lastKey === "*") {
+        if (Array.isArray(current)) {
+          for (let i = 0; i < current.length; i++) {
+            current[i] = value;
+          }
+        } else if (typeof current === "object" && current !== null) {
+          for (const key in current) {
+            if (Object.prototype.hasOwnProperty.call(current, key)) {
+              current[key] = value;
+            }
+          }
+        }
+      } else {
+        if (typeof current === "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+          current[lastKey] = value;
+        }
+      }
+      return true;
     }
-
-    ${redactTmpl(secret, isCensorFct, censorFctTakesPath)}
-    this.compileRestore()
-    ${dynamicRedactTmpl(wcLen > 0, isCensorFct, censorFctTakesPath)}
-    this.secret = originalSecret
-    ${resultTmpl(serialize)}
-  `).bind(state);
-      redact.state = state;
-      if (serialize === false) {
-        redact.restore = (o) => state.restore(o);
-      }
-      return redact;
-    }
-    __name(redactor, "redactor");
-    function redactTmpl(secret, isCensorFct, censorFctTakesPath) {
-      return Object.keys(secret).map((path) => {
-        const { escPath, leadingBracket, path: arrPath } = secret[path];
-        const skip = leadingBracket ? 1 : 0;
-        const delim = leadingBracket ? "" : ".";
-        const hops = [];
-        var match;
-        while ((match = rx.exec(path)) !== null) {
-          const [, ix] = match;
-          const { index, input } = match;
-          if (index > skip) hops.push(input.substring(0, index - (ix ? 0 : 1)));
-        }
-        var existence = hops.map((p) => `o${delim}${p}`).join(" && ");
-        if (existence.length === 0) existence += `o${delim}${path} != null`;
-        else existence += ` && o${delim}${path} != null`;
-        const circularDetection = `
-      switch (true) {
-        ${hops.reverse().map((p) => `
-          case o${delim}${p} === censor:
-            secret[${escPath}].circle = ${JSON.stringify(p)}
-            break
-        `).join("\n")}
-      }
-    `;
-        const censorArgs = censorFctTakesPath ? `val, ${JSON.stringify(arrPath)}` : `val`;
-        return `
-      if (${existence}) {
-        const val = o${delim}${path}
-        if (val === censor) {
-          secret[${escPath}].precensored = true
-        } else {
-          secret[${escPath}].val = val
-          o${delim}${path} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
-          ${circularDetection}
-        }
-      }
-    `;
-      }).join("\n");
-    }
-    __name(redactTmpl, "redactTmpl");
-    function dynamicRedactTmpl(hasWildcards, isCensorFct, censorFctTakesPath) {
-      return hasWildcards === true ? `
-    {
-      const { wildcards, wcLen, groupRedact, nestedRedact } = this
-      for (var i = 0; i < wcLen; i++) {
-        const { before, beforeStr, after, nested } = wildcards[i]
-        if (nested === true) {
-          secret[beforeStr] = secret[beforeStr] || []
-          nestedRedact(secret[beforeStr], o, before, after, censor, ${isCensorFct}, ${censorFctTakesPath})
-        } else secret[beforeStr] = groupRedact(o, before, censor, ${isCensorFct}, ${censorFctTakesPath})
-      }
-    }
-  ` : "";
-    }
-    __name(dynamicRedactTmpl, "dynamicRedactTmpl");
-    function resultTmpl(serialize) {
-      return serialize === false ? `return o` : `
-    var s = this.serialize(o)
-    this.restore(o)
-    return s
-  `;
-    }
-    __name(resultTmpl, "resultTmpl");
-    function strictImpl(strict, serialize) {
-      return strict === true ? `throw Error('fast-redact: primitives cannot be redacted')` : serialize === false ? `return o` : `return this.serialize(o)`;
-    }
-    __name(strictImpl, "strictImpl");
-  }
-});
-
-// node_modules/fast-redact/lib/modifiers.js
-var require_modifiers = __commonJS({
-  "node_modules/fast-redact/lib/modifiers.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      groupRedact,
-      groupRestore,
-      nestedRedact,
-      nestedRestore
-    };
-    function groupRestore({ keys, values, target }) {
-      if (target == null || typeof target === "string") return;
-      const length = keys.length;
-      for (var i = 0; i < length; i++) {
-        const k = keys[i];
-        target[k] = values[i];
-      }
-    }
-    __name(groupRestore, "groupRestore");
-    function groupRedact(o, path, censor, isCensorFct, censorFctTakesPath) {
-      const target = get(o, path);
-      if (target == null || typeof target === "string") return {
-        keys: null,
-        values: null,
-        target,
-        flat: true
-      };
-      const keys = Object.keys(target);
-      const keysLength = keys.length;
-      const pathLength = path.length;
-      const pathWithKey = censorFctTakesPath ? [
-        ...path
-      ] : void 0;
-      const values = new Array(keysLength);
-      for (var i = 0; i < keysLength; i++) {
-        const key = keys[i];
-        values[i] = target[key];
-        if (censorFctTakesPath) {
-          pathWithKey[pathLength] = key;
-          target[key] = censor(target[key], pathWithKey);
-        } else if (isCensorFct) {
-          target[key] = censor(target[key]);
+    __name(setValue, "setValue");
+    function removeKey(obj, parts) {
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (typeof current !== "object" || current === null || !(key in current)) {
+          return false;
+        }
+        if (typeof current[key] !== "object" || current[key] === null) {
+          return false;
+        }
+        current = current[key];
+      }
+      const lastKey = parts[parts.length - 1];
+      if (lastKey === "*") {
+        if (Array.isArray(current)) {
+          for (let i = 0; i < current.length; i++) {
+            current[i] = void 0;
+          }
+        } else if (typeof current === "object" && current !== null) {
+          for (const key in current) {
+            if (Object.prototype.hasOwnProperty.call(current, key)) {
+              delete current[key];
+            }
+          }
+        }
+      } else {
+        if (typeof current === "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+          delete current[lastKey];
+        }
+      }
+      return true;
+    }
+    __name(removeKey, "removeKey");
+    var PATH_NOT_FOUND = Symbol("PATH_NOT_FOUND");
+    function getValueIfExists(obj, parts) {
+      let current = obj;
+      for (const part of parts) {
+        if (current === null || current === void 0) {
+          return PATH_NOT_FOUND;
+        }
+        if (typeof current !== "object" || current === null) {
+          return PATH_NOT_FOUND;
+        }
+        if (!(part in current)) {
+          return PATH_NOT_FOUND;
+        }
+        current = current[part];
+      }
+      return current;
+    }
+    __name(getValueIfExists, "getValueIfExists");
+    function getValue(obj, parts) {
+      let current = obj;
+      for (const part of parts) {
+        if (current === null || current === void 0) {
+          return void 0;
+        }
+        if (typeof current !== "object" || current === null) {
+          return void 0;
+        }
+        current = current[part];
+      }
+      return current;
+    }
+    __name(getValue, "getValue");
+    function redactPaths(obj, paths, censor, remove = false) {
+      for (const path of paths) {
+        const parts = parsePath(path);
+        if (parts.includes("*")) {
+          redactWildcardPath(obj, parts, censor, path, remove);
         } else {
-          target[key] = censor;
+          if (remove) {
+            removeKey(obj, parts);
+          } else {
+            const value = getValueIfExists(obj, parts);
+            if (value === PATH_NOT_FOUND) {
+              continue;
+            }
+            const actualCensor = typeof censor === "function" ? censor(value, parts) : censor;
+            setValue(obj, parts, actualCensor);
+          }
         }
       }
-      return {
-        keys,
-        values,
-        target,
-        flat: true
-      };
     }
-    __name(groupRedact, "groupRedact");
-    function nestedRestore(instructions) {
-      for (let i = 0; i < instructions.length; i++) {
-        const { target, path, value } = instructions[i];
-        let current = target;
-        for (let i2 = path.length - 1; i2 > 0; i2--) {
-          current = current[path[i2]];
-        }
-        current[path[0]] = value;
-      }
-    }
-    __name(nestedRestore, "nestedRestore");
-    function nestedRedact(store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
-      const target = get(o, path);
-      if (target == null) return;
-      const keys = Object.keys(target);
-      const keysLength = keys.length;
-      for (var i = 0; i < keysLength; i++) {
-        const key = keys[i];
-        specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
-      }
-      return store;
-    }
-    __name(nestedRedact, "nestedRedact");
-    function has(obj, prop) {
-      return obj !== void 0 && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
-    }
-    __name(has, "has");
-    function specialSet(store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
-      const afterPathLen = afterPath.length;
-      const lastPathIndex = afterPathLen - 1;
-      const originalKey = k;
-      var i = -1;
-      var n;
-      var nv;
-      var ov;
-      var oov = null;
-      var wc = null;
-      var kIsWc;
-      var wcov;
-      var consecutive = false;
-      var level = 0;
-      var depth = 0;
-      var redactPathCurrent = tree();
-      ov = n = o[k];
-      if (typeof n !== "object") return;
-      while (n != null && ++i < afterPathLen) {
-        depth += 1;
-        k = afterPath[i];
-        oov = ov;
-        if (k !== "*" && !wc && !(typeof n === "object" && k in n)) {
-          break;
+    __name(redactPaths, "redactPaths");
+    function redactWildcardPath(obj, parts, censor, originalPath, remove = false) {
+      const wildcardIndex = parts.indexOf("*");
+      if (wildcardIndex === parts.length - 1) {
+        const parentParts = parts.slice(0, -1);
+        let current = obj;
+        for (const part of parentParts) {
+          if (current === null || current === void 0) return;
+          if (typeof current !== "object" || current === null) return;
+          current = current[part];
         }
-        if (k === "*") {
-          if (wc === "*") {
-            consecutive = true;
+        if (Array.isArray(current)) {
+          if (remove) {
+            for (let i = 0; i < current.length; i++) {
+              current[i] = void 0;
+            }
+          } else {
+            for (let i = 0; i < current.length; i++) {
+              const indexPath = [
+                ...parentParts,
+                i.toString()
+              ];
+              const actualCensor = typeof censor === "function" ? censor(current[i], indexPath) : censor;
+              current[i] = actualCensor;
+            }
           }
-          wc = k;
-          if (i !== lastPathIndex) {
-            continue;
+        } else if (typeof current === "object" && current !== null) {
+          if (remove) {
+            const keysToDelete = [];
+            for (const key in current) {
+              if (Object.prototype.hasOwnProperty.call(current, key)) {
+                keysToDelete.push(key);
+              }
+            }
+            for (const key of keysToDelete) {
+              delete current[key];
+            }
+          } else {
+            for (const key in current) {
+              const keyPath = [
+                ...parentParts,
+                key
+              ];
+              const actualCensor = typeof censor === "function" ? censor(current[key], keyPath) : censor;
+              current[key] = actualCensor;
+            }
           }
         }
-        if (wc) {
-          const wcKeys = Object.keys(n);
-          for (var j = 0; j < wcKeys.length; j++) {
-            const wck = wcKeys[j];
-            wcov = n[wck];
-            kIsWc = k === "*";
-            if (consecutive) {
-              redactPathCurrent = node(redactPathCurrent, wck, depth);
-              level = i;
-              ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
-            } else {
-              if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
-                if (kIsWc) {
-                  ov = wcov;
-                } else {
-                  ov = wcov[k];
-                }
-                nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
-                  ...path,
-                  originalKey,
-                  ...afterPath
-                ]) : censor(ov) : censor;
-                if (kIsWc) {
-                  const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
-                  store.push(rv);
-                  n[wck] = nv;
-                } else {
-                  if (wcov[k] === nv) {
-                  } else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
-                    redactPathCurrent = node(redactPathCurrent, wck, depth);
-                  } else {
-                    redactPathCurrent = node(redactPathCurrent, wck, depth);
-                    const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, o[originalKey]);
-                    store.push(rv);
-                    wcov[k] = nv;
-                  }
-                }
-              }
+      } else {
+        redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove);
+      }
+    }
+    __name(redactWildcardPath, "redactWildcardPath");
+    function redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove = false) {
+      const beforeWildcard = parts.slice(0, wildcardIndex);
+      const afterWildcard = parts.slice(wildcardIndex + 1);
+      const pathArray = [];
+      function traverse(current, pathLength) {
+        if (pathLength === beforeWildcard.length) {
+          if (Array.isArray(current)) {
+            for (let i = 0; i < current.length; i++) {
+              pathArray[pathLength] = i.toString();
+              traverse(current[i], pathLength + 1);
+            }
+          } else if (typeof current === "object" && current !== null) {
+            for (const key in current) {
+              pathArray[pathLength] = key;
+              traverse(current[key], pathLength + 1);
             }
           }
-          wc = null;
+        } else if (pathLength < beforeWildcard.length) {
+          const nextKey = beforeWildcard[pathLength];
+          if (current && typeof current === "object" && current !== null && nextKey in current) {
+            pathArray[pathLength] = nextKey;
+            traverse(current[nextKey], pathLength + 1);
+          }
         } else {
-          ov = n[k];
-          redactPathCurrent = node(redactPathCurrent, k, depth);
-          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
-            ...path,
-            originalKey,
-            ...afterPath
-          ]) : censor(ov) : censor;
-          if (has(n, k) && nv === ov || nv === void 0 && censor !== void 0) {
+          if (afterWildcard.includes("*")) {
+            const wrappedCensor = typeof censor === "function" ? (value, path) => {
+              const fullPath = [
+                ...pathArray.slice(0, pathLength),
+                ...path
+              ];
+              return censor(value, fullPath);
+            } : censor;
+            redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
           } else {
-            const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
-            store.push(rv);
-            n[k] = nv;
+            if (remove) {
+              removeKey(current, afterWildcard);
+            } else {
+              const actualCensor = typeof censor === "function" ? censor(getValue(current, afterWildcard), [
+                ...pathArray.slice(0, pathLength),
+                ...afterWildcard
+              ]) : censor;
+              setValue(current, afterWildcard, actualCensor);
+            }
           }
-          n = n[k];
         }
-        if (typeof n !== "object") break;
-        if (ov === oov || typeof ov === "undefined") {
+      }
+      __name(traverse, "traverse");
+      if (beforeWildcard.length === 0) {
+        traverse(obj, 0);
+      } else {
+        let current = obj;
+        for (let i = 0; i < beforeWildcard.length; i++) {
+          const part = beforeWildcard[i];
+          if (current === null || current === void 0) return;
+          if (typeof current !== "object" || current === null) return;
+          current = current[part];
+          pathArray[i] = part;
+        }
+        if (current !== null && current !== void 0) {
+          traverse(current, beforeWildcard.length);
+        }
+      }
+    }
+    __name(redactIntermediateWildcard, "redactIntermediateWildcard");
+    function buildPathStructure(pathsToClone) {
+      if (pathsToClone.length === 0) {
+        return null;
+      }
+      const pathStructure = /* @__PURE__ */ new Map();
+      for (const path of pathsToClone) {
+        const parts = parsePath(path);
+        let current = pathStructure;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          if (!current.has(part)) {
+            current.set(part, /* @__PURE__ */ new Map());
+          }
+          current = current.get(part);
         }
       }
+      return pathStructure;
     }
-    __name(specialSet, "specialSet");
-    function get(o, p) {
-      var i = -1;
-      var l = p.length;
-      var n = o;
-      while (n != null && ++i < l) {
-        n = n[p[i]];
+    __name(buildPathStructure, "buildPathStructure");
+    function selectiveClone(obj, pathStructure) {
+      if (!pathStructure) {
+        return obj;
       }
-      return n;
-    }
-    __name(get, "get");
-    function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
-      if (level === 0) {
-        if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
-          if (kIsWc) {
-            ov = wcov;
-          } else {
-            ov = wcov[k];
+      function cloneSelectively(source, pathMap, depth = 0) {
+        if (!pathMap || pathMap.size === 0) {
+          return source;
+        }
+        if (source === null || typeof source !== "object") {
+          return source;
+        }
+        if (source instanceof Date) {
+          return new Date(source.getTime());
+        }
+        if (Array.isArray(source)) {
+          const cloned2 = [];
+          for (let i = 0; i < source.length; i++) {
+            const indexStr = i.toString();
+            if (pathMap.has(indexStr) || pathMap.has("*")) {
+              cloned2[i] = cloneSelectively(source[i], pathMap.get(indexStr) || pathMap.get("*"));
+            } else {
+              cloned2[i] = source[i];
+            }
           }
-          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
-            ...path,
-            originalKey,
-            ...afterPath
-          ]) : censor(ov) : censor;
-          if (kIsWc) {
-            const rv = restoreInstr(redactPathCurrent, ov, parent);
-            store.push(rv);
-            n[wck] = nv;
-          } else {
-            if (wcov[k] === nv) {
-            } else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
+          return cloned2;
+        }
+        const cloned = Object.create(Object.getPrototypeOf(source));
+        for (const key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            if (pathMap.has(key) || pathMap.has("*")) {
+              cloned[key] = cloneSelectively(source[key], pathMap.get(key) || pathMap.get("*"));
             } else {
-              const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, parent);
-              store.push(rv);
-              wcov[k] = nv;
+              cloned[key] = source[key];
             }
           }
         }
-      }
-      for (const key in wcov) {
-        if (typeof wcov[key] === "object") {
-          redactPathCurrent = node(redactPathCurrent, key, depth);
-          iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
+        return cloned;
+      }
+      __name(cloneSelectively, "cloneSelectively");
+      return cloneSelectively(obj, pathStructure);
+    }
+    __name(selectiveClone, "selectiveClone");
+    function validatePath(path) {
+      if (typeof path !== "string") {
+        throw new Error("Paths must be (non-empty) strings");
+      }
+      if (path === "") {
+        throw new Error("Invalid redaction path ()");
+      }
+      if (path.includes("..")) {
+        throw new Error(`Invalid redaction path (${path})`);
+      }
+      if (path.includes(",")) {
+        throw new Error(`Invalid redaction path (${path})`);
+      }
+      let bracketCount = 0;
+      let inQuotes = false;
+      let quoteChar = "";
+      for (let i = 0; i < path.length; i++) {
+        const char = path[i];
+        if ((char === '"' || char === "'") && bracketCount > 0) {
+          if (!inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+          } else if (char === quoteChar) {
+            inQuotes = false;
+            quoteChar = "";
+          }
+        } else if (char === "[" && !inQuotes) {
+          bracketCount++;
+        } else if (char === "]" && !inQuotes) {
+          bracketCount--;
+          if (bracketCount < 0) {
+            throw new Error(`Invalid redaction path (${path})`);
+          }
         }
       }
+      if (bracketCount !== 0) {
+        throw new Error(`Invalid redaction path (${path})`);
+      }
     }
-    __name(iterateNthLevel, "iterateNthLevel");
-    function tree() {
-      return {
-        parent: null,
-        key: null,
-        children: [],
-        depth: 0
-      };
-    }
-    __name(tree, "tree");
-    function node(parent, key, depth) {
-      if (parent.depth === depth) {
-        return node(parent.parent, key, depth);
+    __name(validatePath, "validatePath");
+    function validatePaths(paths) {
+      if (!Array.isArray(paths)) {
+        throw new TypeError("paths must be an array");
+      }
+      for (const path of paths) {
+        validatePath(path);
       }
-      var child = {
-        parent,
-        key,
-        depth,
-        children: []
-      };
-      parent.children.push(child);
-      return child;
-    }
-    __name(node, "node");
-    function restoreInstr(node2, value, target) {
-      let current = node2;
-      const path = [];
-      do {
-        path.push(current.key);
-        current = current.parent;
-      } while (current.parent != null);
-      return {
-        path,
-        value,
-        target
-      };
     }
-    __name(restoreInstr, "restoreInstr");
-  }
-});
-
-// node_modules/fast-redact/lib/restorer.js
-var require_restorer = __commonJS({
-  "node_modules/fast-redact/lib/restorer.js"(exports2, module2) {
-    "use strict";
-    var { groupRestore, nestedRestore } = require_modifiers();
-    module2.exports = restorer;
-    function restorer() {
-      return /* @__PURE__ */ __name(function compileRestore() {
-        if (this.restore) {
-          this.restore.state.secret = this.secret;
-          return;
+    __name(validatePaths, "validatePaths");
+    function slowRedact(options = {}) {
+      const { paths = [], censor = "[REDACTED]", serialize = JSON.stringify, strict = true, remove = false } = options;
+      validatePaths(paths);
+      const pathStructure = buildPathStructure(paths);
+      return /* @__PURE__ */ __name(function redact(obj) {
+        if (strict && (obj === null || typeof obj !== "object")) {
+          if (obj === null || obj === void 0) {
+            return serialize ? serialize(obj) : obj;
+          }
+          if (typeof obj !== "object") {
+            return serialize ? serialize(obj) : obj;
+          }
         }
-        const { secret, wcLen } = this;
-        const paths = Object.keys(secret);
-        const resetters = resetTmpl(secret, paths);
-        const hasWildcards = wcLen > 0;
-        const state = hasWildcards ? {
-          secret,
-          groupRestore,
-          nestedRestore
-        } : {
-          secret
-        };
-        this.restore = Function("o", restoreTmpl(resetters, paths, hasWildcards)).bind(state);
-        this.restore.state = state;
-      }, "compileRestore");
-    }
-    __name(restorer, "restorer");
-    function resetTmpl(secret, paths) {
-      return paths.map((path) => {
-        const { circle, escPath, leadingBracket } = secret[path];
-        const delim = leadingBracket ? "" : ".";
-        const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path} = secret[${escPath}].val`;
-        const clear = `secret[${escPath}].val = undefined`;
-        return `
-      if (secret[${escPath}].val !== undefined) {
-        try { ${reset} } catch (e) {}
-        ${clear}
-      }
-    `;
-      }).join("");
-    }
-    __name(resetTmpl, "resetTmpl");
-    function restoreTmpl(resetters, paths, hasWildcards) {
-      const dynamicReset = hasWildcards === true ? `
-    const keys = Object.keys(secret)
-    const len = keys.length
-    for (var i = len - 1; i >= ${paths.length}; i--) {
-      const k = keys[i]
-      const o = secret[k]
-      if (o) {
-        if (o.flat === true) this.groupRestore(o)
-        else this.nestedRestore(o)
-        secret[k] = null
-      }
-    }
-  ` : "";
-      return `
-    const secret = this.secret
-    ${dynamicReset}
-    ${resetters}
-    return o
-  `;
-    }
-    __name(restoreTmpl, "restoreTmpl");
-  }
-});
-
-// node_modules/fast-redact/lib/state.js
-var require_state = __commonJS({
-  "node_modules/fast-redact/lib/state.js"(exports2, module2) {
-    "use strict";
-    module2.exports = state;
-    function state(o) {
-      const { secret, censor, compileRestore, serialize, groupRedact, nestedRedact, wildcards, wcLen } = o;
-      const builder = [
-        {
-          secret,
-          censor,
-          compileRestore
+        const cloned = selectiveClone(obj, pathStructure);
+        const original = obj;
+        let actualCensor = censor;
+        if (typeof censor === "function") {
+          actualCensor = censor;
         }
-      ];
-      if (serialize !== false) builder.push({
-        serialize
-      });
-      if (wcLen > 0) builder.push({
-        groupRedact,
-        nestedRedact,
-        wildcards,
-        wcLen
-      });
-      return Object.assign(...builder);
-    }
-    __name(state, "state");
-  }
-});
-
-// node_modules/fast-redact/index.js
-var require_fast_redact = __commonJS({
-  "node_modules/fast-redact/index.js"(exports2, module2) {
-    "use strict";
-    var validator = require_validator();
-    var parse = require_parse();
-    var redactor = require_redactor();
-    var restorer = require_restorer();
-    var { groupRedact, nestedRedact } = require_modifiers();
-    var state = require_state();
-    var rx = require_rx();
-    var validate = validator();
-    var noop = /* @__PURE__ */ __name((o) => o, "noop");
-    noop.restore = noop;
-    var DEFAULT_CENSOR = "[REDACTED]";
-    fastRedact.rx = rx;
-    fastRedact.validator = validator;
-    module2.exports = fastRedact;
-    function fastRedact(opts = {}) {
-      const paths = Array.from(new Set(opts.paths || []));
-      const serialize = "serialize" in opts ? opts.serialize === false ? opts.serialize : typeof opts.serialize === "function" ? opts.serialize : JSON.stringify : JSON.stringify;
-      const remove = opts.remove;
-      if (remove === true && serialize !== JSON.stringify) {
-        throw Error("fast-redact \u2013 remove option may only be set when serializer is JSON.stringify");
-      }
-      const censor = remove === true ? void 0 : "censor" in opts ? opts.censor : DEFAULT_CENSOR;
-      const isCensorFct = typeof censor === "function";
-      const censorFctTakesPath = isCensorFct && censor.length > 1;
-      if (paths.length === 0) return serialize || noop;
-      validate({
-        paths,
-        serialize,
-        censor
-      });
-      const { wildcards, wcLen, secret } = parse({
-        paths,
-        censor
-      });
-      const compileRestore = restorer();
-      const strict = "strict" in opts ? opts.strict : true;
-      return redactor({
-        secret,
-        wcLen,
-        serialize,
-        strict,
-        isCensorFct,
-        censorFctTakesPath
-      }, state({
-        secret,
-        censor,
-        compileRestore,
-        serialize,
-        groupRedact,
-        nestedRedact,
-        wildcards,
-        wcLen
-      }));
+        redactPaths(cloned, paths, actualCensor, remove);
+        if (serialize === false) {
+          cloned.restore = function() {
+            return deepClone(original);
+          };
+          return cloned;
+        }
+        if (typeof serialize === "function") {
+          return serialize(cloned);
+        }
+        return JSON.stringify(cloned);
+      }, "redact");
     }
-    __name(fastRedact, "fastRedact");
+    __name(slowRedact, "slowRedact");
+    module2.exports = slowRedact;
   }
 });
 
@@ -1131,17 +970,13 @@ var require_symbols = __commonJS({
 var require_redaction = __commonJS({
   "node_modules/pino/lib/redaction.js"(exports2, module2) {
     "use strict";
-    var fastRedact = require_fast_redact();
+    var Redact = require_redact();
     var { redactFmtSym, wildcardFirstSym } = require_symbols();
-    var { rx, validator } = fastRedact;
-    var validate = validator({
-      ERR_PATHS_MUST_BE_STRINGS: /* @__PURE__ */ __name(() => "pino \u2013 redacted paths must be strings", "ERR_PATHS_MUST_BE_STRINGS"),
-      ERR_INVALID_PATH: /* @__PURE__ */ __name((s) => `pino \u2013 redact paths array contains an invalid path (${s})`, "ERR_INVALID_PATH")
-    });
+    var rx = /[^.[\]]+|\[([^[\]]*?)\]/g;
     var CENSOR = "[Redacted]";
     var strict = false;
     function redaction(opts, serialize) {
-      const { paths, censor } = handle(opts);
+      const { paths, censor, remove } = handle(opts);
       const shape = paths.reduce((o, str) => {
         rx.lastIndex = 0;
         const first = rx.exec(str);
@@ -1174,11 +1009,12 @@ var require_redaction = __commonJS({
         return o;
       }, {});
       const result = {
-        [redactFmtSym]: fastRedact({
+        [redactFmtSym]: Redact({
           paths,
           censor,
           serialize,
-          strict
+          strict,
+          remove
         })
       };
       const topCensor = /* @__PURE__ */ __name((...args) => {
@@ -1199,11 +1035,12 @@ var require_redaction = __commonJS({
               ...path
             ]);
           } : censor;
-          o[k] = fastRedact({
+          o[k] = Redact({
             paths: shape[k],
             censor: wrappedCensor,
             serialize,
-            strict
+            strict,
+            remove
           });
         }
         return o;
@@ -1216,7 +1053,6 @@ var require_redaction = __commonJS({
           paths: opts,
           censor: CENSOR
         };
-        validate(opts);
         return opts;
       }
       let { paths, censor = CENSOR, remove } = opts;
@@ -1224,13 +1060,10 @@ var require_redaction = __commonJS({
         throw Error("pino \u2013 redact must contain an array of strings");
       }
       if (remove === true) censor = void 0;
-      validate({
-        paths,
-        censor
-      });
       return {
         paths,
-        censor
+        censor,
+        remove
       };
     }
     __name(handle, "handle");
@@ -3045,7 +2878,7 @@ var require_tools = __commonJS({
       bindings = formatter(bindings);
       for (const key in bindings) {
         value = bindings[key];
-        const valid = key !== "level" && key !== "serializers" && key !== "formatters" && key !== "customLevels" && bindings.hasOwnProperty(key) && value !== void 0;
+        const valid = (key.length < 5 || key !== "level" && key !== "serializers" && key !== "formatters" && key !== "customLevels") && bindings.hasOwnProperty(key) && value !== void 0;
         if (valid === true) {
           value = serializers[key] ? serializers[key](value) : value;
           value = (stringifiers[key] || wildcardStringifier || stringify2)(value, stringifySafe);
@@ -3419,7 +3252,7 @@ var require_meta = __commonJS({
   "node_modules/pino/lib/meta.js"(exports2, module2) {
     "use strict";
     module2.exports = {
-      version: "9.11.0"
+      version: "9.14.0"
     };
   }
 });
@@ -3431,7 +3264,7 @@ var require_proto = __commonJS({
     var { EventEmitter } = require("events");
     var { lsCacheSym, levelValSym, setLevelSym, getLevelSym, chindingsSym, parsedChindingsSym, mixinSym, asJsonSym, writeSym, mixinMergeStrategySym, timeSym, timeSliceIndexSym, streamSym, serializersSym, formattersSym, errorKeySym, messageKeySym, useOnlyCustomLevelsSym, needsMetadataGsym, redactFmtSym, stringifySym, formatOptsSym, stringifiersSym, msgPrefixSym, hooksSym } = require_symbols();
     var { getLevel, setLevel, isLevelEnabled, mappings, initialLsCache, genLsCache, assertNoLevelCollisions } = require_levels();
-    var { asChindings, asJson, buildFormatters, stringify } = require_tools();
+    var { asChindings, asJson, buildFormatters, stringify, noop } = require_tools();
     var { version } = require_meta();
     var redaction = require_redaction();
     var _a3;
@@ -3478,10 +3311,20 @@ var require_proto = __commonJS({
       if (!bindings2) {
         throw Error("missing bindings for child Pino");
       }
-      options = options || {};
       const serializers = this[serializersSym];
       const formatters = this[formattersSym];
       const instance = Object.create(this);
+      if (options == null) {
+        if (instance[formattersSym].bindings !== resetChildingsFormatter) {
+          instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
+        }
+        instance[chindingsSym] = asChindings(instance, bindings2);
+        instance[setLevelSym](this.level);
+        if (this.onChild !== noop) {
+          this.onChild(instance);
+        }
+        return instance;
+      }
       if (options.hasOwnProperty("serializers") === true) {
         instance[serializersSym] = /* @__PURE__ */ Object.create(null);
         for (const k in serializers) {
@@ -3526,10 +3369,8 @@ var require_proto = __commonJS({
         instance[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix;
       }
       instance[chindingsSym] = asChindings(instance, bindings2);
-      if (options.level !== void 0 && options.level !== this.level || options.hasOwnProperty("customLevels")) {
-        const childLevel = options.level || this.level;
-        instance[setLevelSym](childLevel);
-      }
+      const childLevel = options.level || this.level;
+      instance[setLevelSym](childLevel);
       this.onChild(instance);
       return instance;
     }
@@ -3591,9 +3432,6 @@ var require_proto = __commonJS({
       stream.write(streamWriteHook ? streamWriteHook(s) : s);
     }
     __name(write, "write");
-    function noop() {
-    }
-    __name(noop, "noop");
     function flush(cb) {
       if (cb != null && typeof cb !== "function") {
         throw Error("callback must be a function");