@luluyun/automd 1.0.0 → 1.0.2

package/dist/{chunk-sepwzp6y.js → chunk-berrk2wz.js}

@@ -46,9 +46,9 @@ import {
   isObjectLike_default
 } from "./chunk-tj0dzck2.js";
 import {
-  APIUserAbortError,
-  init_sdk
-} from "./chunk-g51z2hdg.js";
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-k2aedy4h.js";
 import {
   getAppConfigHomeDir,
   init_envUtils,
@@ -238,113 +238,6 @@ var init_debugFilter = __esm(() => {
   });
 });
 
-// src/utils/errors.ts
-function isAbortError(e) {
-  return e instanceof AbortError || e instanceof APIUserAbortError || e instanceof Error && e.name === "AbortError";
-}
-function hasExactErrorMessage(error, message) {
-  return error instanceof Error && error.message === message;
-}
-function toError(e) {
-  return e instanceof Error ? e : new Error(String(e));
-}
-function errorMessage(e) {
-  return e instanceof Error ? e.message : String(e);
-}
-function getErrnoCode(e) {
-  if (e && typeof e === "object" && "code" in e && typeof e.code === "string") {
-    return e.code;
-  }
-  return;
-}
-function isENOENT(e) {
-  return getErrnoCode(e) === "ENOENT";
-}
-function getErrnoPath(e) {
-  if (e && typeof e === "object" && "path" in e && typeof e.path === "string") {
-    return e.path;
-  }
-  return;
-}
-function isFsInaccessible(e) {
-  const code = getErrnoCode(e);
-  return code === "ENOENT" || code === "EACCES" || code === "EPERM" || code === "ENOTDIR" || code === "ELOOP";
-}
-function classifyAxiosError(e) {
-  const message = errorMessage(e);
-  if (!e || typeof e !== "object" || !("isAxiosError" in e) || !e.isAxiosError) {
-    return { kind: "other", message };
-  }
-  const err = e;
-  const status = err.response?.status;
-  if (status === 401 || status === 403)
-    return { kind: "auth", status, message };
-  if (err.code === "ECONNABORTED")
-    return { kind: "timeout", status, message };
-  if (err.code === "ECONNREFUSED" || err.code === "ENOTFOUND") {
-    return { kind: "network", status, message };
-  }
-  return { kind: "http", status, message };
-}
-var ClaudeError, MalformedCommandError, AbortError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
-var init_errors = __esm(() => {
-  init_sdk();
-  ClaudeError = class ClaudeError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = this.constructor.name;
-    }
-  };
-  MalformedCommandError = class MalformedCommandError extends Error {
-  };
-  AbortError = class AbortError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "AbortError";
-    }
-  };
-  ConfigParseError = class ConfigParseError extends Error {
-    filePath;
-    defaultConfig;
-    constructor(message, filePath, defaultConfig) {
-      super(message);
-      this.name = "ConfigParseError";
-      this.filePath = filePath;
-      this.defaultConfig = defaultConfig;
-    }
-  };
-  ShellError = class ShellError extends Error {
-    stdout;
-    stderr;
-    code;
-    interrupted;
-    constructor(stdout, stderr, code, interrupted) {
-      super("Shell command failed");
-      this.stdout = stdout;
-      this.stderr = stderr;
-      this.code = code;
-      this.interrupted = interrupted;
-      this.name = "ShellError";
-    }
-  };
-  TeleportOperationError = class TeleportOperationError extends Error {
-    formattedMessage;
-    constructor(message, formattedMessage) {
-      super(message);
-      this.formattedMessage = formattedMessage;
-      this.name = "TeleportOperationError";
-    }
-  };
-  TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS = class TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS extends Error {
-    telemetryMessage;
-    constructor(message, telemetryMessage) {
-      super(message);
-      this.name = "TelemetrySafeError";
-      this.telemetryMessage = telemetryMessage ?? message;
-    }
-  };
-});
-
 // node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/_arrayEach.js
 function arrayEach(array, iteratee) {
   var index = -1, length = array == null ? 0 : array.length;
@@ -520,14 +413,14 @@ function cloneBuffer(buffer, isDeep) {
   buffer.copy(result);
   return result;
 }
-var freeExports, freeModule, moduleExports, Buffer2, allocUnsafe, _cloneBuffer_default;
+var freeExports, freeModule, moduleExports, Buffer, allocUnsafe, _cloneBuffer_default;
 var init__cloneBuffer = __esm(() => {
   init__root();
   freeExports = typeof exports__cloneBuffer == "object" && exports__cloneBuffer && !exports__cloneBuffer.nodeType && exports__cloneBuffer;
   freeModule = freeExports && typeof module__cloneBuffer == "object" && module__cloneBuffer && !module__cloneBuffer.nodeType && module__cloneBuffer;
   moduleExports = freeModule && freeModule.exports === freeExports;
-  Buffer2 = moduleExports ? _root_default.Buffer : undefined;
-  allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : undefined;
+  Buffer = moduleExports ? _root_default.Buffer : undefined;
+  allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
   _cloneBuffer_default = cloneBuffer;
 });
 
@@ -911,19 +804,13 @@ import {
   fsyncSync,
   openSync
 } from "fs";
-function slowLoggingExternal() {
-  return NOOP_LOGGER;
-}
 function jsonStringify(value, replacer, space) {
-  using _ = slowLogging`JSON.stringify(${value})`;
   return JSON.stringify(value, replacer, space);
 }
 function clone(value, options) {
-  using _ = slowLogging`structuredClone(${value})`;
   return structuredClone(value, options);
 }
 function writeFileSync_DEPRECATED(filePath, data, options) {
-  using _ = slowLogging`fs.writeFileSync(${filePath}, ${data})`;
   const needsFlush = options !== null && typeof options === "object" && "flush" in options && options.flush === true;
   if (needsFlush) {
     const encoding = typeof options === "object" && "encoding" in options ? options.encoding : undefined;
@@ -942,8 +829,7 @@ function writeFileSync_DEPRECATED(filePath, data, options) {
     fsWriteFileSync(filePath, data, options);
   }
 }
-var SLOW_OPERATION_THRESHOLD_MS, NOOP_LOGGER, slowLogging, jsonParse = (text, reviver) => {
-  using _ = slowLogging`JSON.parse(${text})`;
+var SLOW_OPERATION_THRESHOLD_MS, NOOP_LOGGER, jsonParse = (text, reviver) => {
   return typeof reviver === "undefined" ? JSON.parse(text) : JSON.parse(text, reviver);
 };
 var init_slowOperations = __esm(() => {
@@ -966,402 +852,11 @@ var init_slowOperations = __esm(() => {
     return Infinity;
   })();
   NOOP_LOGGER = { [Symbol.dispose]() {} };
-  slowLogging = slowLoggingExternal;
-});
-
-// src/utils/fsOperations.ts
-import * as fs from "fs";
-import {
-  mkdir as mkdirPromise,
-  open,
-  readdir as readdirPromise,
-  readFile as readFilePromise,
-  rename as renamePromise,
-  rmdir as rmdirPromise,
-  rm as rmPromise,
-  stat as statPromise,
-  unlink as unlinkPromise
-} from "fs/promises";
-import { homedir } from "os";
-import * as nodePath from "path";
-function safeResolvePath(fs2, filePath) {
-  if (filePath.startsWith("//") || filePath.startsWith("\\\\")) {
-    return { resolvedPath: filePath, isSymlink: false, isCanonical: false };
-  }
-  try {
-    const stats = fs2.lstatSync(filePath);
-    if (stats.isFIFO() || stats.isSocket() || stats.isCharacterDevice() || stats.isBlockDevice()) {
-      return { resolvedPath: filePath, isSymlink: false, isCanonical: false };
-    }
-    const resolvedPath = fs2.realpathSync(filePath);
-    return {
-      resolvedPath,
-      isSymlink: resolvedPath !== filePath,
-      isCanonical: true
-    };
-  } catch (_error) {
-    return { resolvedPath: filePath, isSymlink: false, isCanonical: false };
-  }
-}
-function isDuplicatePath(fs2, filePath, loadedPaths) {
-  const { resolvedPath } = safeResolvePath(fs2, filePath);
-  if (loadedPaths.has(resolvedPath)) {
-    return true;
-  }
-  loadedPaths.add(resolvedPath);
-  return false;
-}
-function resolveDeepestExistingAncestorSync(fs2, absolutePath) {
-  let dir = absolutePath;
-  const segments = [];
-  while (dir !== nodePath.dirname(dir)) {
-    let st;
-    try {
-      st = fs2.lstatSync(dir);
-    } catch {
-      segments.unshift(nodePath.basename(dir));
-      dir = nodePath.dirname(dir);
-      continue;
-    }
-    if (st.isSymbolicLink()) {
-      try {
-        const resolved = fs2.realpathSync(dir);
-        return segments.length === 0 ? resolved : nodePath.join(resolved, ...segments);
-      } catch {
-        const target = fs2.readlinkSync(dir);
-        const absTarget = nodePath.isAbsolute(target) ? target : nodePath.resolve(nodePath.dirname(dir), target);
-        return segments.length === 0 ? absTarget : nodePath.join(absTarget, ...segments);
-      }
-    }
-    try {
-      const resolved = fs2.realpathSync(dir);
-      if (resolved !== dir) {
-        return segments.length === 0 ? resolved : nodePath.join(resolved, ...segments);
-      }
-    } catch {}
-    return;
-  }
-  return;
-}
-function getPathsForPermissionCheck(inputPath) {
-  let path = inputPath;
-  if (path === "~") {
-    path = homedir().normalize("NFC");
-  } else if (path.startsWith("~/")) {
-    path = nodePath.join(homedir().normalize("NFC"), path.slice(2));
-  }
-  const pathSet = new Set;
-  const fsImpl = getFsImplementation();
-  pathSet.add(path);
-  if (path.startsWith("//") || path.startsWith("\\\\")) {
-    return Array.from(pathSet);
-  }
-  try {
-    let currentPath = path;
-    const visited = new Set;
-    const maxDepth = 40;
-    for (let depth = 0;depth < maxDepth; depth++) {
-      if (visited.has(currentPath)) {
-        break;
-      }
-      visited.add(currentPath);
-      if (!fsImpl.existsSync(currentPath)) {
-        if (currentPath === path) {
-          const resolved = resolveDeepestExistingAncestorSync(fsImpl, path);
-          if (resolved !== undefined) {
-            pathSet.add(resolved);
-          }
-        }
-        break;
-      }
-      const stats = fsImpl.lstatSync(currentPath);
-      if (stats.isFIFO() || stats.isSocket() || stats.isCharacterDevice() || stats.isBlockDevice()) {
-        break;
-      }
-      if (!stats.isSymbolicLink()) {
-        break;
-      }
-      const target = fsImpl.readlinkSync(currentPath);
-      const absoluteTarget = nodePath.isAbsolute(target) ? target : nodePath.resolve(nodePath.dirname(currentPath), target);
-      pathSet.add(absoluteTarget);
-      currentPath = absoluteTarget;
-    }
-  } catch {}
-  const { resolvedPath, isSymlink } = safeResolvePath(fsImpl, path);
-  if (isSymlink && resolvedPath !== path) {
-    pathSet.add(resolvedPath);
-  }
-  return Array.from(pathSet);
-}
-function getFsImplementation() {
-  return activeFs;
-}
-async function readFileRange(path, offset, maxBytes) {
-  await using fh = await open(path, "r");
-  const size = (await fh.stat()).size;
-  if (size <= offset) {
-    return null;
-  }
-  const bytesToRead = Math.min(size - offset, maxBytes);
-  const buffer = Buffer.allocUnsafe(bytesToRead);
-  let totalRead = 0;
-  while (totalRead < bytesToRead) {
-    const { bytesRead } = await fh.read(buffer, totalRead, bytesToRead - totalRead, offset + totalRead);
-    if (bytesRead === 0) {
-      break;
-    }
-    totalRead += bytesRead;
-  }
-  return {
-    content: buffer.toString("utf8", 0, totalRead),
-    bytesRead: totalRead,
-    bytesTotal: size
-  };
-}
-async function tailFile(path, maxBytes) {
-  await using fh = await open(path, "r");
-  const size = (await fh.stat()).size;
-  if (size === 0) {
-    return { content: "", bytesRead: 0, bytesTotal: 0 };
-  }
-  const offset = Math.max(0, size - maxBytes);
-  const bytesToRead = size - offset;
-  const buffer = Buffer.allocUnsafe(bytesToRead);
-  let totalRead = 0;
-  while (totalRead < bytesToRead) {
-    const { bytesRead } = await fh.read(buffer, totalRead, bytesToRead - totalRead, offset + totalRead);
-    if (bytesRead === 0) {
-      break;
-    }
-    totalRead += bytesRead;
-  }
-  return {
-    content: buffer.toString("utf8", 0, totalRead),
-    bytesRead: totalRead,
-    bytesTotal: size
-  };
-}
-async function* readLinesReverse(path) {
-  const CHUNK_SIZE = 1024 * 4;
-  const fileHandle = await open(path, "r");
-  try {
-    const stats = await fileHandle.stat();
-    let position = stats.size;
-    let remainder = Buffer.alloc(0);
-    const buffer = Buffer.alloc(CHUNK_SIZE);
-    while (position > 0) {
-      const currentChunkSize = Math.min(CHUNK_SIZE, position);
-      position -= currentChunkSize;
-      await fileHandle.read(buffer, 0, currentChunkSize, position);
-      const combined = Buffer.concat([
-        buffer.subarray(0, currentChunkSize),
-        remainder
-      ]);
-      const firstNewline = combined.indexOf(10);
-      if (firstNewline === -1) {
-        remainder = combined;
-        continue;
-      }
-      remainder = Buffer.from(combined.subarray(0, firstNewline));
-      const lines = combined.toString("utf8", firstNewline + 1).split(`
-`);
-      for (let i = lines.length - 1;i >= 0; i--) {
-        const line = lines[i];
-        if (line) {
-          yield line;
-        }
-      }
-    }
-    if (remainder.length > 0) {
-      yield remainder.toString("utf8");
-    }
-  } finally {
-    await fileHandle.close();
-  }
-}
-var NodeFsOperations, activeFs;
-var init_fsOperations = __esm(() => {
-  init_errors();
-  init_slowOperations();
-  NodeFsOperations = {
-    cwd() {
-      return process.cwd();
-    },
-    existsSync(fsPath) {
-      using _ = slowLogging`fs.existsSync(${fsPath})`;
-      return fs.existsSync(fsPath);
-    },
-    async stat(fsPath) {
-      return statPromise(fsPath);
-    },
-    async readdir(fsPath) {
-      return readdirPromise(fsPath, { withFileTypes: true });
-    },
-    async unlink(fsPath) {
-      return unlinkPromise(fsPath);
-    },
-    async rmdir(fsPath) {
-      return rmdirPromise(fsPath);
-    },
-    async rm(fsPath, options) {
-      return rmPromise(fsPath, options);
-    },
-    async mkdir(dirPath, options) {
-      try {
-        await mkdirPromise(dirPath, { recursive: true, ...options });
-      } catch (e) {
-        if (getErrnoCode(e) !== "EEXIST")
-          throw e;
-      }
-    },
-    async readFile(fsPath, options) {
-      return readFilePromise(fsPath, { encoding: options.encoding });
-    },
-    async rename(oldPath, newPath) {
-      return renamePromise(oldPath, newPath);
-    },
-    statSync(fsPath) {
-      using _ = slowLogging`fs.statSync(${fsPath})`;
-      return fs.statSync(fsPath);
-    },
-    lstatSync(fsPath) {
-      using _ = slowLogging`fs.lstatSync(${fsPath})`;
-      return fs.lstatSync(fsPath);
-    },
-    readFileSync(fsPath, options) {
-      using _ = slowLogging`fs.readFileSync(${fsPath})`;
-      return fs.readFileSync(fsPath, { encoding: options.encoding });
-    },
-    readFileBytesSync(fsPath) {
-      using _ = slowLogging`fs.readFileBytesSync(${fsPath})`;
-      return fs.readFileSync(fsPath);
-    },
-    readSync(fsPath, options) {
-      using _ = slowLogging`fs.readSync(${fsPath}, ${options.length} bytes)`;
-      let fd = undefined;
-      try {
-        fd = fs.openSync(fsPath, "r");
-        const buffer = Buffer.alloc(options.length);
-        const bytesRead = fs.readSync(fd, buffer, 0, options.length, 0);
-        return { buffer, bytesRead };
-      } finally {
-        if (fd)
-          fs.closeSync(fd);
-      }
-    },
-    appendFileSync(path, data, options) {
-      using _ = slowLogging`fs.appendFileSync(${path}, ${data.length} chars)`;
-      if (options?.mode !== undefined) {
-        try {
-          const fd = fs.openSync(path, "ax", options.mode);
-          try {
-            fs.appendFileSync(fd, data);
-          } finally {
-            fs.closeSync(fd);
-          }
-          return;
-        } catch (e) {
-          if (getErrnoCode(e) !== "EEXIST")
-            throw e;
-        }
-      }
-      fs.appendFileSync(path, data);
-    },
-    copyFileSync(src, dest) {
-      using _ = slowLogging`fs.copyFileSync(${src} \u2192 ${dest})`;
-      fs.copyFileSync(src, dest);
-    },
-    unlinkSync(path) {
-      using _ = slowLogging`fs.unlinkSync(${path})`;
-      fs.unlinkSync(path);
-    },
-    renameSync(oldPath, newPath) {
-      using _ = slowLogging`fs.renameSync(${oldPath} \u2192 ${newPath})`;
-      fs.renameSync(oldPath, newPath);
-    },
-    linkSync(target, path) {
-      using _ = slowLogging`fs.linkSync(${target} \u2192 ${path})`;
-      fs.linkSync(target, path);
-    },
-    symlinkSync(target, path, type) {
-      using _ = slowLogging`fs.symlinkSync(${target} \u2192 ${path})`;
-      fs.symlinkSync(target, path, type);
-    },
-    readlinkSync(path) {
-      using _ = slowLogging`fs.readlinkSync(${path})`;
-      return fs.readlinkSync(path);
-    },
-    realpathSync(path) {
-      using _ = slowLogging`fs.realpathSync(${path})`;
-      return fs.realpathSync(path).normalize("NFC");
-    },
-    mkdirSync(dirPath, options) {
-      using _ = slowLogging`fs.mkdirSync(${dirPath})`;
-      const mkdirOptions = {
-        recursive: true
-      };
-      if (options?.mode !== undefined) {
-        mkdirOptions.mode = options.mode;
-      }
-      try {
-        fs.mkdirSync(dirPath, mkdirOptions);
-      } catch (e) {
-        if (getErrnoCode(e) !== "EEXIST")
-          throw e;
-      }
-    },
-    readdirSync(dirPath) {
-      using _ = slowLogging`fs.readdirSync(${dirPath})`;
-      return fs.readdirSync(dirPath, { withFileTypes: true });
-    },
-    readdirStringSync(dirPath) {
-      using _ = slowLogging`fs.readdirStringSync(${dirPath})`;
-      return fs.readdirSync(dirPath);
-    },
-    isDirEmptySync(dirPath) {
-      using _ = slowLogging`fs.isDirEmptySync(${dirPath})`;
-      const files = this.readdirSync(dirPath);
-      return files.length === 0;
-    },
-    rmdirSync(dirPath) {
-      using _ = slowLogging`fs.rmdirSync(${dirPath})`;
-      fs.rmdirSync(dirPath);
-    },
-    rmSync(path, options) {
-      using _ = slowLogging`fs.rmSync(${path})`;
-      fs.rmSync(path, options);
-    },
-    createWriteStream(path) {
-      return fs.createWriteStream(path);
-    },
-    async readFileBytes(fsPath, maxBytes) {
-      if (maxBytes === undefined) {
-        return readFilePromise(fsPath);
-      }
-      const handle = await open(fsPath, "r");
-      try {
-        const { size } = await handle.stat();
-        const readSize = Math.min(size, maxBytes);
-        const buffer = Buffer.allocUnsafe(readSize);
-        let offset = 0;
-        while (offset < readSize) {
-          const { bytesRead } = await handle.read(buffer, offset, readSize - offset, offset);
-          if (bytesRead === 0)
-            break;
-          offset += bytesRead;
-        }
-        return offset < readSize ? buffer.subarray(0, offset) : buffer;
-      } finally {
-        await handle.close();
-      }
-    }
-  };
-  activeFs = NodeFsOperations;
 });
 
 // src/utils/debug.ts
 import { appendFile, mkdir, symlink, unlink } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname, join } from "path";
 function enableDebugLogging() {
   const wasActive = isDebugMode() || process.env.USER_TYPE === "ant";
   runtimeDebugEnabled = true;
@@ -1399,7 +894,7 @@ function getDebugWriter() {
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
         const path = getDebugLogPath();
-        const dir = dirname2(path);
+        const dir = dirname(path);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -1452,7 +947,7 @@ function logForDebugging(message, { level } = {
   getDebugWriter().write(output);
 }
 function getDebugLogPath() {
-  return getDebugFilePath() ?? process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join2(getAppConfigHomeDir(), "debug", `${getSessionId()}.txt`);
+  return getDebugFilePath() ?? process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join(getAppConfigHomeDir(), "debug", `${getSessionId()}.txt`);
 }
 function logAntError(context, error) {
   if (process.env.USER_TYPE !== "ant") {
@@ -1520,12 +1015,12 @@ var init_debug = __esm(() => {
   updateLatestDebugLogSymlink = memoize_default(async () => {
     try {
       const debugLogPath = getDebugLogPath();
-      const debugLogsDir = dirname2(debugLogPath);
-      const latestSymlinkPath = join2(debugLogsDir, "latest");
+      const debugLogsDir = dirname(debugLogPath);
+      const latestSymlinkPath = join(debugLogsDir, "latest");
       await unlink(latestSymlinkPath).catch(() => {});
       await symlink(debugLogPath, latestSymlinkPath);
     } catch {}
   });
 });
 
-export { createBufferedWriter, init_bufferedWriter, registerCleanup, runCleanupFunctions, init_cleanupRegistry, ClaudeError, MalformedCommandError, AbortError, isAbortError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, hasExactErrorMessage, toError, errorMessage, getErrnoCode, isENOENT, getErrnoPath, isFsInaccessible, classifyAxiosError, init_errors, _defineProperty_default, init__defineProperty, _baseAssignValue_default, init__baseAssignValue, _assignValue_default, init__assignValue, _copyObject_default, init__copyObject, keysIn_default, init_keysIn, _cloneBuffer_default, init__cloneBuffer, _copyArray_default, init__copyArray, _getPrototype_default, init__getPrototype, _getAllKeysIn_default, init__getAllKeysIn, _cloneTypedArray_default, init__cloneTypedArray, _initCloneObject_default, init__initCloneObject, _baseClone_default, init__baseClone, cloneDeep_default, init_cloneDeep, slowLogging, jsonStringify, jsonParse, clone, writeFileSync_DEPRECATED, init_slowOperations, safeResolvePath, isDuplicatePath, getPathsForPermissionCheck, getFsImplementation, readFileRange, tailFile, readLinesReverse, init_fsOperations, getMinDebugLogLevel, isDebugMode, enableDebugLogging, getDebugFilter, isDebugToStdErr, getDebugFilePath, setHasFormattedOutput, getHasFormattedOutput, flushDebugLogs, logForDebugging, getDebugLogPath, logAntError, init_debug };
+export { createBufferedWriter, init_bufferedWriter, registerCleanup, runCleanupFunctions, init_cleanupRegistry, _defineProperty_default, init__defineProperty, _baseAssignValue_default, init__baseAssignValue, _assignValue_default, init__assignValue, _copyObject_default, init__copyObject, keysIn_default, init_keysIn, _cloneBuffer_default, init__cloneBuffer, _copyArray_default, init__copyArray, _getPrototype_default, init__getPrototype, _getAllKeysIn_default, init__getAllKeysIn, _cloneTypedArray_default, init__cloneTypedArray, _initCloneObject_default, init__initCloneObject, _baseClone_default, init__baseClone, cloneDeep_default, init_cloneDeep, jsonStringify, jsonParse, clone, writeFileSync_DEPRECATED, init_slowOperations, getMinDebugLogLevel, isDebugMode, enableDebugLogging, getDebugFilter, isDebugToStdErr, getDebugFilePath, setHasFormattedOutput, getHasFormattedOutput, flushDebugLogs, logForDebugging, getDebugLogPath, logAntError, init_debug };