@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/cjs/object.js

@@ -0,0 +1,634 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var object_exports = {};
+__export(object_exports, {
+  clone: () => clone,
+  createNestedObject: () => createNestedObject,
+  createObjectWithoutPrototype: () => createObjectWithoutPrototype,
+  deepClone: () => deepClone,
+  deepContains: () => deepContains,
+  deepDestringifyFunctions: () => deepDestringifyFunctions,
+  deepMerge: () => deepMerge,
+  deepStringifyFunctions: () => deepStringifyFunctions,
+  destringifyGlobalScope: () => destringifyGlobalScope,
+  detectInfiniteLoop: () => detectInfiniteLoop,
+  excludeKeysFromObject: () => excludeKeysFromObject,
+  exec: () => exec,
+  getInObjectByPath: () => getInObjectByPath,
+  hasFunction: () => hasFunction,
+  hasOwnProperty: () => hasOwnProperty,
+  isCyclic: () => isCyclic,
+  isEmpty: () => isEmpty,
+  isEmptyObject: () => isEmptyObject,
+  isEqualDeep: () => isEqualDeep,
+  makeObjectWithoutPrototype: () => makeObjectWithoutPrototype,
+  map: () => map,
+  merge: () => merge,
+  objectToString: () => objectToString,
+  overwrite: () => overwrite,
+  overwriteDeep: () => overwriteDeep,
+  overwriteShallow: () => overwriteShallow,
+  removeFromObject: () => removeFromObject,
+  removeNestedKeyByPath: () => removeNestedKeyByPath,
+  setInObjectByPath: () => setInObjectByPath,
+  stringToObject: () => stringToObject
+});
+module.exports = __toCommonJS(object_exports);
+var import_globals = require("./globals.js");
+var import_types = require("./types.js");
+var import_array = require("./array.js");
+var import_string = require("./string.js");
+var import_node = require("./node.js");
+var import_keys = require("./keys.js");
+const ENV = process.env.NODE_ENV;
+const _startsWithDunder = (e) => e.charCodeAt(0) === 95 && e.charCodeAt(1) === 95;
+const exec = (param, element, state, context) => {
+  if ((0, import_types.isFunction)(param)) {
+    if (!element) return;
+    if (typeof param.call !== "function") return param;
+    return param.call(
+      element,
+      element,
+      state || element.state,
+      context || element.context
+    );
+  }
+  if (param != null && element?.context?.plugins && ((0, import_types.isArray)(param) || (0, import_types.isObject)(param) && !(0, import_node.isDOMNode)(param))) {
+    const plugins = element.context.plugins;
+    for (const plugin of plugins) {
+      if (plugin.resolveHandler) {
+        const resolved = plugin.resolveHandler(param, element);
+        if (typeof resolved === "function") {
+          return exec(resolved, element, state, context);
+        }
+      }
+    }
+  }
+  return param;
+};
+const map = (obj, extention, element) => {
+  for (const e in extention) {
+    obj[e] = exec(extention[e], element);
+  }
+};
+const merge = (element, obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set;
+  for (const e in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, e)) continue;
+    if (_startsWithDunder(e)) continue;
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+    if (element[e] === void 0) {
+      element[e] = obj[e];
+    }
+  }
+  return element;
+};
+const deepMerge = (element, extend, excludeFrom = import_keys.METHODS_EXL) => {
+  return _deepMerge(element, extend, excludeFrom, null);
+};
+const _deepMerge = (element, extend, excludeFrom, ancestors) => {
+  if (element === extend) return element;
+  if (ancestors) {
+    for (let i = 0; i < ancestors.length; i += 2) {
+      if (ancestors[i] === element && ancestors[i + 1] === extend) return element;
+    }
+  }
+  const useSet = excludeFrom instanceof Set;
+  for (const e in extend) {
+    if (!Object.prototype.hasOwnProperty.call(extend, e)) continue;
+    if (_startsWithDunder(e)) continue;
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if ((0, import_types.isObjectLike)(elementProp) && (0, import_types.isObjectLike)(extendProp)) {
+      const stack = ancestors || [];
+      stack.push(element, extend);
+      _deepMerge(elementProp, extendProp, excludeFrom, stack);
+      stack.length -= 2;
+    } else if (elementProp === void 0) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+const clone = (obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set;
+  const o = {};
+  for (const prop in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
+    if (_startsWithDunder(prop)) continue;
+    if (useSet ? excludeFrom.has(prop) : excludeFrom.includes(prop)) continue;
+    o[prop] = obj[prop];
+  }
+  return o;
+};
+const deepClone = (obj, options = {}) => {
+  const {
+    exclude = [],
+    cleanUndefined = false,
+    cleanNull = false,
+    window: targetWindow,
+    visited = /* @__PURE__ */ new WeakMap(),
+    handleExtends = false
+  } = options;
+  const contentWindow = targetWindow || import_globals.window || globalThis;
+  if (!(0, import_types.isObjectLike)(obj) || (0, import_node.isDOMNode)(obj)) {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return visited.get(obj);
+  }
+  const isArr = (0, import_types.isArray)(obj);
+  const clone2 = isArr ? [] : {};
+  visited.set(obj, clone2);
+  const excludeSet = exclude instanceof Set ? exclude : exclude.length > 3 ? new Set(exclude) : null;
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    if (_startsWithDunder(key) || key === "__proto__") continue;
+    if (excludeSet ? excludeSet.has(key) : exclude.includes(key)) continue;
+    const value = obj[key];
+    if (cleanUndefined && value === void 0) continue;
+    if (cleanNull && value === null) continue;
+    if ((0, import_node.isDOMNode)(value)) {
+      clone2[key] = value;
+      continue;
+    }
+    if (handleExtends && key === "extends" && (0, import_types.isArray)(value)) {
+      clone2[key] = (0, import_array.unstackArrayOfObjects)(value, exclude);
+      continue;
+    }
+    if ((0, import_types.isFunction)(value)) {
+      clone2[key] = value;
+      continue;
+    }
+    if ((0, import_types.isObjectLike)(value)) {
+      clone2[key] = deepClone(value, {
+        ...options,
+        visited
+      });
+    } else {
+      clone2[key] = value;
+    }
+  }
+  return clone2;
+};
+const deepStringifyFunctions = (obj, stringified = {}) => {
+  if (obj.node || obj.__ref || obj.parent || obj.__element || obj.parse) {
+    ;
+    (obj.__element || obj.parent?.__element).warn(
+      "Trying to clone element or state at",
+      obj
+    );
+    obj = obj.parse?.();
+  }
+  for (const prop in obj) {
+    const objProp = obj[prop];
+    if ((0, import_types.isFunction)(objProp)) {
+      stringified[prop] = objProp.toString();
+    } else if ((0, import_types.isObject)(objProp)) {
+      stringified[prop] = {};
+      deepStringifyFunctions(objProp, stringified[prop]);
+    } else if ((0, import_types.isArray)(objProp)) {
+      const arr = stringified[prop] = [];
+      for (let i = 0; i < objProp.length; i++) {
+        const v = objProp[i];
+        if ((0, import_types.isObject)(v)) {
+          arr[i] = {};
+          deepStringifyFunctions(v, arr[i]);
+        } else if ((0, import_types.isFunction)(v)) {
+          arr[i] = v.toString();
+        } else {
+          arr[i] = v;
+        }
+      }
+    } else {
+      stringified[prop] = objProp;
+    }
+  }
+  return stringified;
+};
+const OBJ_TO_STR_SPECIAL_CHARS = /* @__PURE__ */ new Set([
+  "&",
+  "*",
+  "-",
+  ":",
+  "%",
+  "{",
+  "}",
+  ">",
+  "<",
+  "@",
+  ".",
+  "/",
+  "!",
+  " "
+]);
+const objectToString = (obj = {}, indent = 0) => {
+  if (obj === null || typeof obj !== "object") {
+    return String(obj);
+  }
+  let hasKeys = false;
+  for (const _k in obj) {
+    hasKeys = true;
+    break;
+  }
+  if (!hasKeys) return "{}";
+  const spaces = "  ".repeat(indent);
+  let str = "{\n";
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    const value = obj[key];
+    let keyNeedsQuotes = false;
+    for (let i = 0; i < key.length; i++) {
+      if (OBJ_TO_STR_SPECIAL_CHARS.has(key[i])) {
+        keyNeedsQuotes = true;
+        break;
+      }
+    }
+    const stringedKey = keyNeedsQuotes ? `'${key}'` : key;
+    str += `${spaces}  ${stringedKey}: `;
+    if ((0, import_types.isArray)(value)) {
+      str += "[\n";
+      for (const element of value) {
+        if ((0, import_types.isObjectLike)(element) && element !== null) {
+          str += `${spaces}    ${objectToString(element, indent + 2)},
+`;
+        } else if ((0, import_types.isString)(element)) {
+          str += `${spaces}    '${element}',
+`;
+        } else {
+          str += `${spaces}    ${element},
+`;
+        }
+      }
+      str += `${spaces}  ]`;
+    } else if ((0, import_types.isObjectLike)(value)) {
+      str += objectToString(value, indent + 1);
+    } else if ((0, import_types.isString)(value)) {
+      str += (0, import_string.stringIncludesAny)(value, ["\n", "'"]) ? `\`${value}\`` : `'${value}'`;
+    } else {
+      str += value;
+    }
+    str += ",\n";
+  }
+  str += `${spaces}}`;
+  return str;
+};
+const FN_PATTERNS = [
+  /^\(\s*\{[^}]*\}\s*\)\s*=>/,
+  /^(\([^)]*\)|[^=]*)\s*=>/,
+  /^function[\s(]/,
+  /^async\s+/,
+  /^\(\s*function/,
+  /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/
+];
+const RE_JSON_LIKE = /^["[{]/;
+const hasFunction = (str) => {
+  if (!str) return false;
+  const trimmed = str.trim().replace(/\n\s*/g, " ").trim();
+  if (trimmed === "" || trimmed === "{}" || trimmed === "[]") return false;
+  const isFn = FN_PATTERNS.some((pattern) => pattern.test(trimmed));
+  if (!isFn) return false;
+  const firstChar = trimmed.charCodeAt(0);
+  const hasArrow = trimmed.includes("=>");
+  if (firstChar === 123 && !hasArrow) return false;
+  if (firstChar === 91) return false;
+  if (RE_JSON_LIKE.test(trimmed) && !hasArrow) return false;
+  return true;
+};
+const __globalEval = (src) => (0, eval)(src);
+const deepDestringifyFunctions = (obj, destringified = {}, opts = { window: { eval: __globalEval } }) => {
+  for (const prop in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
+    const objProp = obj[prop];
+    if ((0, import_types.isString)(objProp)) {
+      if (hasFunction(objProp)) {
+        try {
+          destringified[prop] = opts.window.eval(`(${objProp})`);
+        } catch (e) {
+          if (e) destringified[prop] = objProp;
+        }
+      } else {
+        destringified[prop] = objProp;
+      }
+    } else if ((0, import_types.isArray)(objProp)) {
+      const arr = destringified[prop] = [];
+      for (let i = 0; i < objProp.length; i++) {
+        const arrProp = objProp[i];
+        if ((0, import_types.isString)(arrProp)) {
+          if (hasFunction(arrProp)) {
+            try {
+              arr.push(opts.window.eval(`(${arrProp})`));
+            } catch (e) {
+              if (e) arr.push(arrProp);
+            }
+          } else {
+            arr.push(arrProp);
+          }
+        } else if ((0, import_types.isObject)(arrProp)) {
+          arr.push(deepDestringifyFunctions(arrProp));
+        } else {
+          arr.push(arrProp);
+        }
+      }
+    } else if ((0, import_types.isObject)(objProp)) {
+      destringified[prop] = deepDestringifyFunctions(
+        objProp,
+        destringified[prop]
+      );
+    } else {
+      destringified[prop] = objProp;
+    }
+  }
+  return destringified;
+};
+const destringifyGlobalScope = (gs) => {
+  if (!gs || typeof gs !== "object") return gs;
+  const result = {};
+  const fnEntries = [];
+  for (const key of Object.keys(gs)) {
+    const val = gs[key];
+    if ((0, import_types.isString)(val) && hasFunction(val)) {
+      fnEntries.push([key, val]);
+    } else {
+      result[key] = val;
+    }
+  }
+  for (const [key, fnStr] of fnEntries) {
+    try {
+      const varDecls = Object.keys(result).map((k) => `var ${k} = __gs__[${JSON.stringify(k)}];`).join("\n");
+      result[key] = import_globals.window.eval(
+        `(function(__gs__) { ${varDecls}
+ return (${fnStr}); })`
+      )(result);
+    } catch (e) {
+      try {
+        result[key] = import_globals.window.eval(`(${fnStr})`);
+      } catch (_) {
+        result[key] = fnStr;
+      }
+    }
+  }
+  return result;
+};
+const stringToObject = (str, opts = { verbose: true }) => {
+  try {
+    return str ? import_globals.window.eval("(" + str + ")") : {};
+  } catch (e) {
+    if (opts.verbose) console.warn(e);
+  }
+};
+const hasOwnProperty = (o, ...args) => Object.prototype.hasOwnProperty.call(o, ...args);
+const isEmpty = (o) => {
+  for (const _ in o) return false;
+  return true;
+};
+const isEmptyObject = (o) => (0, import_types.isObject)(o) && isEmpty(o);
+const makeObjectWithoutPrototype = () => /* @__PURE__ */ Object.create(null);
+const overwrite = (element, params, opts = {}) => {
+  const excl = opts.exclude || [];
+  const allowDunder = opts.preventUnderscore;
+  for (const e in params) {
+    if (excl.includes(e) || !allowDunder && _startsWithDunder(e)) continue;
+    if (params[e] !== void 0) {
+      element[e] = params[e];
+    }
+  }
+  return element;
+};
+const overwriteShallow = (obj, params, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set;
+  for (const e in params) {
+    if (_startsWithDunder(e)) continue;
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+    obj[e] = params[e];
+  }
+  return obj;
+};
+const overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new WeakMap()) => {
+  if (!(0, import_types.isObjectLike)(obj) || !(0, import_types.isObjectLike)(params) || (0, import_node.isDOMNode)(obj) || (0, import_node.isDOMNode)(params)) {
+    return params;
+  }
+  if (visited.has(obj)) return visited.get(obj);
+  visited.set(obj, obj);
+  const excl = opts.exclude;
+  const exclSet = excl ? excl instanceof Set ? excl : new Set(excl) : null;
+  const forcedExclude = !opts.preventForce;
+  for (const e in params) {
+    if (!Object.prototype.hasOwnProperty.call(params, e)) continue;
+    if (exclSet && exclSet.has(e) || forcedExclude && _startsWithDunder(e))
+      continue;
+    const objProp = obj[e];
+    const paramsProp = params[e];
+    if ((0, import_node.isDOMNode)(paramsProp)) {
+      obj[e] = paramsProp;
+    } else if ((0, import_types.isObjectLike)(objProp) && (0, import_types.isObjectLike)(paramsProp)) {
+      obj[e] = overwriteDeep(objProp, paramsProp, opts, visited);
+    } else if (paramsProp !== void 0) {
+      obj[e] = paramsProp;
+    }
+  }
+  return obj;
+};
+const isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
+  if (typeof param !== "object" || typeof element !== "object" || param === null || element === null) {
+    return param === element;
+  }
+  if (visited.has(param) || visited.has(element)) {
+    return true;
+  }
+  visited.add(param);
+  visited.add(element);
+  const keysParam = Object.keys(param);
+  const keysElement = Object.keys(element);
+  if (keysParam.length !== keysElement.length) {
+    return false;
+  }
+  for (let i = 0; i < keysParam.length; i++) {
+    const key = keysParam[i];
+    if (!Object.prototype.hasOwnProperty.call(element, key)) {
+      return false;
+    }
+    if (!isEqualDeep(param[key], element[key], visited)) {
+      return false;
+    }
+  }
+  return true;
+};
+const DEEP_CONTAINS_IGNORED = /* @__PURE__ */ new Set(["node", "__ref"]);
+const deepContains = (obj1, obj2, ignoredKeys = DEEP_CONTAINS_IGNORED) => {
+  if (obj1 === obj2) return true;
+  if (!(0, import_types.isObjectLike)(obj1) || !(0, import_types.isObjectLike)(obj2)) return obj1 === obj2;
+  if ((0, import_node.isDOMNode)(obj1) || (0, import_node.isDOMNode)(obj2)) return obj1 === obj2;
+  const ignored = ignoredKeys instanceof Set ? ignoredKeys : new Set(ignoredKeys);
+  const visited = /* @__PURE__ */ new WeakSet();
+  function checkContains(target, source) {
+    if (visited.has(source)) return true;
+    visited.add(source);
+    for (const key in source) {
+      if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+      if (ignored.has(key)) continue;
+      if (!Object.prototype.hasOwnProperty.call(target, key)) return false;
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if ((0, import_node.isDOMNode)(sourceValue) || (0, import_node.isDOMNode)(targetValue)) {
+        if (sourceValue !== targetValue) return false;
+      } else if ((0, import_types.isObjectLike)(sourceValue) && (0, import_types.isObjectLike)(targetValue)) {
+        if (!checkContains(targetValue, sourceValue)) return false;
+      } else if (sourceValue !== targetValue) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return checkContains(obj1, obj2);
+};
+const removeFromObject = (obj, props) => {
+  if (props === void 0 || props === null) return obj;
+  if ((0, import_types.is)(props)("string", "number")) {
+    delete obj[props];
+  } else if ((0, import_types.isArray)(props)) {
+    for (let i = 0; i < props.length; i++) delete obj[props[i]];
+  } else {
+    throw new Error(
+      "Invalid input: props must be a string or an array of strings"
+    );
+  }
+  return obj;
+};
+const createObjectWithoutPrototype = (obj) => {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  const newObj = /* @__PURE__ */ Object.create(null);
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      newObj[key] = createObjectWithoutPrototype(obj[key]);
+    }
+  }
+  return newObj;
+};
+const createNestedObject = (arr, lastValue) => {
+  if (arr.length === 0) return lastValue;
+  const nestedObject = {};
+  let current = nestedObject;
+  for (let i = 0; i < arr.length; i++) {
+    if (i === arr.length - 1 && lastValue) {
+      current[arr[i]] = lastValue;
+    } else {
+      current[arr[i]] = {};
+      current = current[arr[i]];
+    }
+  }
+  return nestedObject;
+};
+const removeNestedKeyByPath = (obj, path) => {
+  if (!Array.isArray(path)) {
+    throw new Error("Path must be an array.");
+  }
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    if (current[path[i]] === void 0) return;
+    current = current[path[i]];
+  }
+  const lastKey = path[path.length - 1];
+  if (current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+    delete current[lastKey];
+  }
+};
+const setInObjectByPath = (obj, path, value) => {
+  if (!Array.isArray(path)) {
+    throw new Error("Path must be an array.");
+  }
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    if (!current[path[i]] || typeof current[path[i]] !== "object") {
+      current[path[i]] = {};
+    }
+    current = current[path[i]];
+  }
+  current[path[path.length - 1]] = value;
+  return obj;
+};
+const getInObjectByPath = (obj, path) => {
+  if (!Array.isArray(path)) {
+    throw new Error("Path must be an array.");
+  }
+  let current = obj;
+  for (let i = 0; i < path.length; i++) {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    current = current[path[i]];
+  }
+  return current;
+};
+const detectInfiniteLoop = (arr) => {
+  const maxRepeats = 10;
+  let pattern = [];
+  let repeatCount = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (pattern.length < 2) {
+      pattern.push(arr[i]);
+    } else {
+      if (arr[i] === pattern[i % 2]) {
+        repeatCount++;
+      } else {
+        pattern = [arr[i - 1], arr[i]];
+        repeatCount = 1;
+      }
+      if (repeatCount >= maxRepeats * 2) {
+        if (ENV === "test" || ENV === "development") {
+          console.warn(
+            "Warning: Potential infinite loop detected due to repeated sequence:",
+            pattern
+          );
+        }
+        return true;
+      }
+    }
+  }
+};
+const isCyclic = (obj) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function detect(obj2) {
+    if (obj2 && typeof obj2 === "object") {
+      if (seen.has(obj2)) return true;
+      seen.add(obj2);
+      for (const key in obj2) {
+        if (Object.prototype.hasOwnProperty.call(obj2, key) && detect(obj2[key])) {
+          console.log(obj2, "cycle at " + key);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  return detect(obj);
+};
+const excludeKeysFromObject = (obj, excludedKeys) => {
+  const excluded = excludedKeys instanceof Set ? excludedKeys : new Set(excludedKeys);
+  const result = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key) && !excluded.has(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+};

package/dist/cjs/projectKeys.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var projectKeys_exports = {};
+__export(projectKeys_exports, {
+  UNIVERSAL_RESERVED_KEYS: () => UNIVERSAL_RESERVED_KEYS,
+  isUniversallyReservedKey: () => isUniversallyReservedKey
+});
+module.exports = __toCommonJS(projectKeys_exports);
+const UNIVERSAL_RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "_id",
+  "__v",
+  "id",
+  "createdAt",
+  "updatedAt",
+  "schema"
+]);
+const isUniversallyReservedKey = (key) => typeof key === "string" && UNIVERSAL_RESERVED_KEYS.has(key);