@ariestools/sdk 7.0.7 → 7.0.8

package/dist/neutral/neutral/url.d.ts

@@ -0,0 +1,2 @@
+export * from '../modules/url/index-neutral.js';
+//# sourceMappingURL=url.d.ts.map

package/dist/neutral/neutral/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/neutral/url.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAA"}

package/dist/neutral/node/platform.d.ts

@@ -0,0 +1,2 @@
+export * from '../modules/platform/node/index.js';
+//# sourceMappingURL=platform.d.ts.map

package/dist/neutral/node/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../src/node/platform.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAA"}

package/dist/neutral/node/url.d.ts

@@ -0,0 +1,2 @@
+export * from '../modules/url/index-node.js';
+//# sourceMappingURL=url.d.ts.map

package/dist/neutral/node/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/node/url.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA"}

package/dist/neutral/object.d.ts

@@ -1 +1,2 @@
-export * from '../_pkg/object/neutral/index-un-deprecated.ts'
+export * from './modules/object/index-un-deprecated.js';
+//# sourceMappingURL=object.d.ts.map

package/dist/neutral/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/object.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA"}

package/dist/neutral/object.mjs

@@ -1 +1,442 @@
-export * from '../_pkg/object/neutral/index-un-deprecated.mjs'
+// src/modules/typeof/is.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+function isDefined(value) {
+  return !isUndefined(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTruthy(value) {
+  return !!value;
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+
+// src/modules/typeof/isType.ts
+var isType = (value, expectedType) => {
+  const typeofValue = typeof value;
+  switch (expectedType) {
+    case "array": {
+      return Array.isArray(value);
+    }
+    case "null": {
+      return value === null;
+    }
+    case "undefined": {
+      return value === void 0;
+    }
+    case "object": {
+      if (value === null) {
+        return false;
+      }
+      return typeofValue === "object" && !Array.isArray(value);
+    }
+    default: {
+      return typeofValue === expectedType;
+    }
+  }
+};
+
+// src/modules/assert/assertDefinedEx.ts
+function assertDefinedEx(expr, func) {
+  if (expr !== void 0) return expr;
+  if (typeof func === "function") {
+    const errorOrMessage = func(expr);
+    throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  }
+  if (func !== void 0) {
+    throw new Error("Invalid assertDefinedEx usage: second argument must be a function or undefined");
+  }
+  throw new Error("Assertion failed: value is undefined");
+}
+
+// src/modules/assert/assertEx.ts
+function assertEx(expr, func) {
+  if (expr !== void 0 && expr !== null && expr !== false && expr !== 0 && expr !== "" && expr !== 0n) return expr;
+  if (typeof func === "function") {
+    const errorOrMessage = func(expr);
+    throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  }
+  if (func !== void 0) {
+    throw new Error("Invalid assertEx usage: second argument must be a function or undefined");
+  }
+  throw new Error("Assertion failed");
+}
+
+// src/modules/object/AsTypeFactory.ts
+var AsTypeFactory = {
+  create: (typeCheck) => {
+    const func = (value, assertOrConfig, config) => {
+      const isPredicate = typeof assertOrConfig === "number";
+      const resolvedAssert = isPredicate || typeof assertOrConfig === "object" ? void 0 : assertOrConfig;
+      const resolvedConfig = isPredicate ? void 0 : typeof assertOrConfig === "object" ? assertOrConfig : config;
+      const isRequired = isTruthy(resolvedConfig?.required);
+      if (!isRequired && (value === void 0 || value === null)) {
+        return void 0;
+      }
+      if (isPromise(value)) {
+        throw new TypeError('un-awaited promises may not be sent to "as" functions');
+      }
+      const result = typeCheck(value, resolvedConfig) ? value : void 0;
+      if (resolvedAssert !== void 0) {
+        const message = typeof resolvedAssert === "function" ? resolvedAssert : () => resolvedAssert;
+        return assertDefinedEx(result, message);
+      }
+      return result;
+    };
+    return func;
+  },
+  createOptional: (typeCheck) => {
+    const func = (value) => {
+      if (value === void 0 || value === null) return void 0;
+      if (isPromise(value)) {
+        throw new TypeError('un-awaited promises may not be sent to "as" functions');
+      }
+      return typeCheck(value) ? value : void 0;
+    };
+    return func;
+  }
+};
+
+// src/modules/object/AsObjectFactory.ts
+var AsObjectFactory = {
+  create: (typeCheck) => {
+    return AsTypeFactory.create(typeCheck);
+  },
+  createOptional: (typeCheck) => {
+    return AsTypeFactory.createOptional(typeCheck);
+  }
+};
+
+// src/modules/object/asObject.ts
+var asAnyObject = (() => AsObjectFactory.create((obj) => isObject(obj)))();
+
+// src/modules/object/deepMerge.ts
+var isUnsafeKey = (key) => typeof key === "string" && ["__proto__", "constructor", "prototype"].includes(key);
+var isPlainObject = (value) => {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+function merge(target, source, options) {
+  if (!source || typeof source !== "object") return target;
+  for (const key of Reflect.ownKeys(source)) {
+    if (isUnsafeKey(key)) {
+      continue;
+    }
+    const value = source[key];
+    if (Array.isArray(value)) {
+      const targetValue = target[key];
+      target[key] = options?.arrayStrategy === "concat" && Array.isArray(targetValue) ? [...targetValue, ...value] : value;
+    } else if (value !== null && typeof value === "object" && isPlainObject(value)) {
+      const targetValue = target[key];
+      if (targetValue === void 0 || targetValue === null || typeof targetValue !== "object" || !isPlainObject(targetValue)) {
+        target[key] = {};
+      }
+      merge(target[key], value, options);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+function createDeepMerge(options) {
+  return function deepMerge2(...objects) {
+    const result = options.mutate === true ? objects[0] ?? {} : {};
+    for (const obj of objects) {
+      merge(result, obj, options);
+    }
+    return result;
+  };
+}
+var deepMerge = createDeepMerge({ arrayStrategy: "overwrite", mutate: false });
+
+// src/modules/object/IsObjectFactory.ts
+var IsObjectFactory = class {
+  /**
+   * Creates a type-guard function that validates an object matches the given shape and passes additional checks.
+   * @param shape - An optional map of property names to expected types.
+   * @param additionalChecks - Optional extra type-check functions to run after shape validation.
+   * @returns A type-guard function for type T.
+   */
+  create(shape, additionalChecks) {
+    return (obj, config) => {
+      if (!isObject(obj)) {
+        return false;
+      }
+      const log = typeof config === "object" ? config.log : void 0;
+      return (
+        // do primary check
+        Object.entries(shape ?? {}).filter(([key, type]) => {
+          const isResult = isType(obj[key], type);
+          if (!isResult && isTruthy(log)) {
+            const logger = typeof log === "object" ? log : console;
+            logger.warn(`isType Failed: ${key}: ${type}`);
+          }
+          return !isResult;
+        }).length === 0 && (additionalChecks?.reduce((prev, check) => prev && check(obj, { log }), true) ?? true)
+      );
+    };
+  }
+};
+
+// src/modules/object/JsonObject.ts
+import * as z3 from "zod/mini";
+
+// src/modules/zod/zodAsFactory.ts
+import * as z from "zod/v4/core";
+
+// src/modules/error/assert.ts
+var assertError = (value, assert, defaultMessage) => {
+  if (!isUndefined(assert)) {
+    const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+    if (isString(assertString) || assertString) {
+      throw new Error(assertString === true ? defaultMessage : assertString);
+    }
+  }
+  return void 0;
+};
+
+// src/modules/zod/zodAsFactory.ts
+var formatZodValue = (value) => {
+  const json = JSON.stringify(value);
+  return json ?? String(value);
+};
+function zodAsFactory(zod, name) {
+  function asFunc(value, assert) {
+    const result = z.safeParse(zod, value);
+    if (result.success) {
+      return value;
+    }
+    if (assert !== void 0) {
+      let assertConfig;
+      switch (typeof assert) {
+        case "string": {
+          assertConfig = `[${name}][${formatZodValue(value)}] ${assert}`;
+          break;
+        }
+        case "object": {
+          assertConfig = `[${name}][${assert.name}][${formatZodValue(value)}] ${result.error.message}`;
+          break;
+        }
+        case "boolean": {
+          assertConfig = `[${name}][${formatZodValue(value)}] ${result.error.message}`;
+          break;
+        }
+        case "function": {
+          assertConfig = assert(value, result.error.message);
+          break;
+        }
+      }
+      return assertError(value, assertConfig, result.error.message);
+    }
+  }
+  return asFunc;
+}
+
+// src/modules/zod/zodIsFactory.ts
+import * as z2 from "zod/v4/core";
+function zodIsFactory(zod) {
+  return (value) => z2.safeParse(zod, value).success;
+}
+
+// src/modules/zod/zodToFactory.ts
+function zodToFactory(zod, name) {
+  const as = zodAsFactory(zod, name);
+  function toFunc(value, assert) {
+    if (isDefined(assert)) {
+      return as(value, assert);
+    }
+    return as(value);
+  }
+  return toFunc;
+}
+
+// src/modules/object/JsonObject.ts
+var JsonArrayZod = z3.array(z3.lazy(() => JsonValueZod));
+var JsonValueZod = z3.lazy(() => z3.union([
+  z3.string(),
+  z3.number(),
+  z3.boolean(),
+  z3.null(),
+  z3.array(JsonValueZod),
+  z3.record(z3.string(), JsonValueZod)
+  // object with string keys and JSON values
+]));
+var JsonObjectZod = z3.record(z3.string(), JsonValueZod);
+var isJsonValue = zodIsFactory(JsonValueZod);
+var asJsonValue = zodAsFactory(JsonValueZod, "asJsonValue");
+var toJsonValue = zodToFactory(JsonValueZod, "toJsonValue");
+var isJsonArray = zodIsFactory(JsonArrayZod);
+var asJsonArray = zodAsFactory(JsonArrayZod, "asJsonArray");
+var toJsonArray = zodToFactory(JsonArrayZod, "toJsonArray");
+var isJsonObject = zodIsFactory(JsonObjectZod);
+var asJsonObject = zodAsFactory(JsonObjectZod, "asJsonObject");
+var toJsonObject = zodToFactory(JsonObjectZod, "toJsonObject");
+
+// src/modules/object/ObjectWrapper.ts
+var ObjectWrapper = class {
+  obj;
+  constructor(obj) {
+    this.obj = obj;
+  }
+  get stringKeyObj() {
+    return this.obj;
+  }
+};
+
+// src/modules/object/omitBy.ts
+var omitByArray = (obj, predicate, maxDepth) => {
+  return obj.map((value) => {
+    return value !== null && typeof value === "object" ? omitBy(value, predicate, maxDepth) : value;
+  });
+};
+var omitByObject = (obj, predicate, maxDepth) => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (!predicate(value, key)) {
+      result[key] = value !== null && typeof value === "object" ? omitBy(value, predicate, maxDepth - 1) : value;
+    }
+  }
+  return result;
+};
+var omitBy = (obj, predicate, maxDepth = 1) => {
+  if (maxDepth <= 0) {
+    return obj;
+  }
+  return Array.isArray(obj) ? omitByArray(obj, predicate, maxDepth - 1) : omitByObject(obj, predicate, maxDepth - 1);
+};
+var omitByPrefixPredicate = (prefix) => (_, key) => {
+  assertEx(typeof key === "string", () => `Invalid key type [${key}, ${typeof key}]`);
+  return key.startsWith(prefix);
+};
+var omitByPrefix = (payload, prefix, maxDepth = 100) => {
+  return omitBy(payload, omitByPrefixPredicate(prefix), maxDepth);
+};
+
+// src/modules/object/pickBy.ts
+var pickByArray = (obj, predicate, maxDepth) => {
+  return obj.map((value) => {
+    return value !== null && typeof value === "object" ? pickBy(value, predicate, maxDepth) : value;
+  });
+};
+var pickByObject = (obj, predicate, maxDepth) => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (predicate(value, key)) {
+      result[key] = value !== null && typeof value === "object" ? pickBy(value, predicate, maxDepth - 1) : value;
+    }
+  }
+  return result;
+};
+var pickBy = (obj, predicate, maxDepth = 1) => {
+  if (maxDepth <= 0) {
+    return obj;
+  }
+  return Array.isArray(obj) ? pickByArray(obj, predicate, maxDepth - 1) : pickByObject(obj, predicate, maxDepth - 1);
+};
+var pickByPrefixPredicate = (prefix) => (_, key) => {
+  assertEx(typeof key === "string", () => `Invalid key type [${key}, ${typeof key}]`);
+  return key.startsWith(prefix);
+};
+var pickByPrefix = (payload, prefix, maxDepth = 100) => {
+  return pickBy(payload, pickByPrefixPredicate(prefix), maxDepth);
+};
+
+// src/modules/object/removeFields.ts
+var removeFields = (obj, fields) => {
+  const clone = { ...obj };
+  for (const field of fields) {
+    delete clone[field];
+  }
+  return clone;
+};
+
+// src/modules/object/toSafeJson.ts
+var toSafeJsonArray = (value, cycleList, maxDepth = 3) => {
+  return value.map((item) => toSafeJsonValue(item, cycleList, maxDepth));
+};
+var toSafeJsonObject = (value, cycleList, maxDepth = 3) => {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    result[key] = entry === void 0 ? "[Undefined]" : toSafeJsonValue(entry, cycleList, maxDepth);
+  }
+  return result;
+};
+var toSafeJsonValue = (value, cycleList, maxDepth = 3) => {
+  if (maxDepth <= 0 && typeof value === "object") {
+    return "[MaxDepth]";
+  }
+  if (cycleList?.includes(value) === true) {
+    return "[Circular]";
+  }
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+    case "number": {
+      return value;
+    }
+    case "object": {
+      if (value === null) {
+        return null;
+      }
+      const newCycleList = cycleList ?? [];
+      newCycleList.push(value);
+      if (Array.isArray(value)) {
+        return toSafeJsonArray(value, newCycleList, maxDepth - 1);
+      }
+      return toSafeJsonObject(value, newCycleList, maxDepth - 1);
+    }
+    default: {
+      return `[${typeof value}]`;
+    }
+  }
+};
+var toSafeJsonString = (value, maxDepth = 3) => {
+  return JSON.stringify(toSafeJson(value, maxDepth), null, 2);
+};
+var toSafeJson = (value, maxDepth = 3) => {
+  return toSafeJsonValue(value, void 0, maxDepth);
+};
+
+// src/modules/object/Validator.ts
+var ValidatorBase = class extends ObjectWrapper {
+};
+export {
+  AsObjectFactory,
+  AsTypeFactory,
+  IsObjectFactory,
+  JsonObjectZod,
+  ObjectWrapper,
+  ValidatorBase,
+  asAnyObject,
+  asJsonArray,
+  asJsonObject,
+  asJsonValue,
+  createDeepMerge,
+  deepMerge,
+  isJsonArray,
+  isJsonObject,
+  isJsonValue,
+  omitBy,
+  omitByPrefix,
+  pickBy,
+  pickByPrefix,
+  removeFields,
+  toJsonArray,
+  toJsonObject,
+  toJsonValue,
+  toSafeJson,
+  toSafeJsonArray,
+  toSafeJsonObject,
+  toSafeJsonString,
+  toSafeJsonValue
+};
+//# sourceMappingURL=object.mjs.map

package/dist/neutral/object.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/typeof/is.ts", "../../src/modules/typeof/isType.ts", "../../src/modules/assert/assertDefinedEx.ts", "../../src/modules/assert/assertEx.ts", "../../src/modules/object/AsTypeFactory.ts", "../../src/modules/object/AsObjectFactory.ts", "../../src/modules/object/asObject.ts", "../../src/modules/object/deepMerge.ts", "../../src/modules/object/IsObjectFactory.ts", "../../src/modules/object/JsonObject.ts", "../../src/modules/zod/zodAsFactory.ts", "../../src/modules/error/assert.ts", "../../src/modules/zod/zodIsFactory.ts", "../../src/modules/zod/zodToFactory.ts", "../../src/modules/object/ObjectWrapper.ts", "../../src/modules/object/omitBy.ts", "../../src/modules/object/pickBy.ts", "../../src/modules/object/removeFields.ts", "../../src/modules/object/toSafeJson.ts", "../../src/modules/object/Validator.ts"],
+  "sourcesContent": ["/// <reference lib=\"dom\" />\n\n/** A function type that accepts any arguments and returns unknown. */\nexport type AnyFunction = (...args: unknown[]) => unknown\n\n/** A union of valid object key types. */\nexport type RecordKey = string | number | symbol\n\n/** Type guard that checks whether a value is undefined. */\nexport function isUndefined(value: unknown): value is undefined\nexport function isUndefined<T>(value: T): value is Extract<T, undefined>\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined\n}\n\n/** Type guard that checks whether a value is not undefined. */\nexport function isDefined<T>(value: T): value is Exclude<T, undefined> {\n  return !isUndefined(value)\n}\n\n/** Type guard that checks whether a value is null. */\nexport function isNull(value: unknown): value is null\nexport function isNull<T>(value: T): value is Extract<T, null>\nexport function isNull(value: unknown): value is null {\n  return value === null\n}\n\n/** Type guard that checks whether a value is neither undefined nor null. */\nexport function isDefinedNotNull<T>(value: T): value is Exclude<T, undefined | null> {\n  return !isUndefined(value) && !isNull(value)\n}\n\n/** Type guard that checks whether a value is undefined or null. */\nexport function isUndefinedOrNull(value: unknown): value is undefined | null\nexport function isUndefinedOrNull<T>(value: T): value is Extract<T, undefined | null>\nexport function isUndefinedOrNull(value: unknown): value is undefined | null {\n  return isUndefined(value) || isNull(value)\n}\n\n/** Type guard that checks whether a value is a bigint. */\nexport function isBigInt(value: unknown): value is bigint\nexport function isBigInt<T extends bigint>(value: T): value is Extract<T, bigint>\nexport function isBigInt(value: unknown): value is bigint {\n  return typeof value === 'bigint'\n}\n\n/** Type guard that checks whether a value is a string. */\nexport function isString(value: unknown): value is string\nexport function isString<T extends string>(value: T): value is Extract<T, string>\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string'\n}\n\n/** Type guard that checks whether a value is a number. */\nexport function isNumber(value: unknown): value is number\nexport function isNumber<T extends number>(value: T): value is Extract<T, number>\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number'\n}\n\n/** Type guard that checks whether a value is a plain object (not null and not an array). */\nexport function isObject(value: unknown): value is object\nexport function isObject<T extends object>(value: T): value is Extract<T, object>\nexport function isObject(value: unknown): value is object {\n  return (typeof value === 'object') && (value !== null) && !Array.isArray(value)\n}\n\n/** Type guard that checks whether a value is an array. */\nexport function isArray(value: unknown): value is readonly unknown[]\nexport function isArray<T>(value: T): value is Extract<T, readonly unknown[]>\nexport function isArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value)\n}\n\n/** Type guard that checks whether a value is a function. */\nexport function isFunction(value: unknown): value is AnyFunction\nexport function isFunction<T extends AnyFunction>(value: T): value is Extract<T, AnyFunction>\nexport function isFunction(value: unknown): value is AnyFunction {\n  return typeof value === 'function'\n}\n\n/** Type guard that checks whether a value is a symbol. */\nexport function isSymbol(value: unknown): value is symbol\nexport function isSymbol<T extends symbol>(value: T): value is Extract<T, symbol>\nexport function isSymbol(value: unknown): value is symbol {\n  return typeof value === 'symbol'\n}\n\n/** Type guard that checks whether a value is an object with no own keys. */\nexport function isEmptyObject(value: unknown): value is {}\nexport function isEmptyObject<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>\nexport function isEmptyObject(value: unknown): value is {} {\n  return isObject(value) && Object.keys(value).length === 0\n}\n\n/** Type guard that checks whether a value is an empty string. */\nexport function isEmptyString(value: unknown): value is ''\nexport function isEmptyString<T extends string>(value: T): value is Extract<T, ''>\nexport function isEmptyString(value: unknown): value is '' {\n  return isString(value) && value.length === 0\n}\n\n/** Type guard that checks whether a value is an empty array. */\nexport function isEmptyArray(value: unknown): value is []\nexport function isEmptyArray<T extends unknown[]>(value: T): value is Extract<T, unknown[]>\nexport function isEmptyArray(value: unknown): value is [] {\n  return isArray(value) && value.length === 0\n}\n\n/** Type guard that checks whether a value is a non-empty array. */\nexport function isPopulatedArray(value: unknown): value is readonly unknown[]\nexport function isPopulatedArray<T extends unknown[]>(value: T): value is Extract<T, readonly unknown[]>\nexport function isPopulatedArray(value: unknown): value is readonly unknown[] {\n  return isArray(value) && value.length > 0\n}\n\n/** Type guard that checks whether a value is empty (empty string, empty array, or empty object). */\nexport function isEmpty<T>(value: unknown): value is T\nexport function isEmpty<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>\nexport function isEmpty<T extends unknown[]>(value: T): value is Extract<T, never[]>\nexport function isEmpty<T>(value: unknown): value is T {\n  return isEmptyString(value) || isEmptyArray(value) || isEmptyObject(value)\n}\n\n/** Type guard that checks whether a value is falsy (0, null, undefined, false, '', or 0n). */\nexport function isFalsy<T>(value: T): value is Extract<T, 0 | null | undefined | false | '' | 0n>\nexport function isFalsy<T extends boolean>(value: T): value is Extract<T, false>\nexport function isFalsy<T extends number>(value: T): value is Extract<T, 0>\nexport function isFalsy<T extends bigint>(value: T): value is Extract<T, 0n>\nexport function isFalsy<T extends null>(value: T): value is Extract<T, null>\nexport function isFalsy<T extends undefined>(value: T): value is Extract<T, undefined>\nexport function isFalsy<T extends string>(value: T): value is Extract<T, ''>\nexport function isFalsy<T>(value: T): value is T {\n  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- mirrors JavaScript falsy semantics (incl. NaN)\n  return !value\n}\n\n/** Type guard that checks whether a value is truthy (not 0, null, undefined, false, '', or 0n). */\nexport function isTruthy<T>(value: T): value is Exclude<T, 0 | null | undefined | false | '' | 0n>\nexport function isTruthy<T extends boolean>(value: T): value is Extract<T, true>\nexport function isTruthy<T extends number>(value: T): value is Extract<T, number>\nexport function isTruthy<T extends bigint>(value: T): value is Extract<T, bigint>\nexport function isTruthy<T extends null>(value: T): value is Extract<T, null>\nexport function isTruthy<T extends undefined>(value: T): value is Extract<T, undefined>\nexport function isTruthy<T extends string>(value: T): value is Extract<T, string>\nexport function isTruthy<T>(value: T): value is T {\n  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- mirrors JavaScript truthy semantics\n  return !!value\n}\n\n/** Type guard that checks whether a value is a boolean. */\nexport function isBoolean(value: unknown): value is boolean\nexport function isBoolean<T extends boolean>(value: T): value is Extract<T, boolean>\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean'\n}\n\n/** Type guard that checks whether a value is a string that can be parsed as a valid date. */\nexport function isDateString(value: unknown): value is string\nexport function isDateString<T>(value: T): value is Extract<T, string>\nexport function isDateString(value: unknown): value is string {\n  return isString(value) && !Number.isNaN(Date.parse(value))\n}\n\n/** Type guard that checks whether a value is a Date instance. */\nexport function isDate(value: unknown): value is Date\nexport function isDate<T>(value: T): value is Extract<T, Date>\nexport function isDate(value: unknown): value is Date {\n  return value instanceof Date\n}\n\n/** Type guard that checks whether a value is a RegExp instance. */\nexport function isRegExp(value: unknown): value is RegExp\nexport function isRegExp<T extends RegExp>(value: T): value is Extract<T, RegExp>\nexport function isRegExp(value: unknown): value is RegExp {\n  return value instanceof RegExp\n}\n\n/** Type guard that checks whether a value is an Error instance. */\nexport function isError(value: unknown): value is Error\nexport function isError<T>(value: T): value is Extract<T, Error>\nexport function isError(value: unknown): value is Error {\n  return value instanceof Error\n}\n\n/** Type guard that checks whether a value is a Promise instance. */\nexport function isPromise(value: unknown): value is Promise<unknown>\nexport function isPromise<T>(value: T): value is Extract<T, Promise<unknown>>\nexport function isPromise(value: unknown): value is Promise<unknown> {\n  return value instanceof Promise\n}\n\n/** Type guard that checks whether a value is promise-like (has a `then` method). */\nexport function isPromiseLike(value: unknown): value is Promise<unknown>\nexport function isPromiseLike<T>(value: T): value is Extract<T, Promise<unknown>>\nexport function isPromiseLike(value: unknown): value is Promise<unknown> {\n  return (\n    typeof value === 'object'\n    && value !== null\n    && typeof (value as Record<string, unknown>).then === 'function'\n  )\n}\n\n/** Type guard that checks whether a value is a Map instance. */\nexport function isMap(value: unknown): value is Map<unknown, unknown>\nexport function isMap<K, V, T extends Map<K, V>>(value: T): value is Extract<T, Map<K, V>>\nexport function isMap(value: unknown): value is Map<unknown, unknown> {\n  return value instanceof Map\n}\n\n/** Type guard that checks whether a value is an ArrayBufferView (e.g., TypedArray or DataView). */\nexport function isArrayBufferView(value: unknown): value is ArrayBufferView\nexport function isArrayBufferView<T extends ArrayBufferView>(value: T): value is Extract<T, ArrayBufferView>\nexport function isArrayBufferView(value: unknown): value is ArrayBufferView {\n  return ArrayBuffer.isView(value)\n}\n\n/** Type guard that checks whether a value is a Set instance. */\nexport function isSet(value: unknown): value is Set<unknown>\nexport function isSet<T extends Set<unknown>>(value: T): value is Extract<T, Set<unknown>>\nexport function isSet(value: unknown): value is Set<unknown> {\n  return value instanceof Set\n}\n\n/** Type guard that checks whether a value is a WeakMap instance. */\nexport function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown>\nexport function isWeakMap<K extends WeakKey, V, T extends WeakMap<K, V>>(value: T): value is Extract<T, WeakMap<K, V>>\nexport function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown> {\n  return value instanceof WeakMap\n}\n\n/** Type guard that checks whether a value is a WeakSet instance. */\nexport function isWeakSet(value: unknown): value is WeakSet<WeakKey>\nexport function isWeakSet<K extends WeakKey, T extends WeakSet<K>>(value: T): value is Extract<T, WeakSet<K>>\nexport function isWeakSet(value: unknown): value is WeakSet<WeakKey> {\n  return value instanceof WeakSet\n}\n\n/** Type guard that checks whether a value is a DataView instance. */\nexport function isDataView(value: unknown): value is DataView\nexport function isDataView<T>(value: T): value is Extract<T, DataView>\nexport function isDataView(value: unknown): value is DataView {\n  return value instanceof DataView\n}\n\n/** Type guard that checks whether a value is a Blob instance. */\nexport function isBlob(value: unknown): value is Blob\nexport function isBlob<T extends Blob>(value: T): value is Extract<T, Blob>\nexport function isBlob(value: unknown): value is Blob {\n  return typeof Blob !== 'undefined' && value instanceof Blob\n}\n\n/** Type guard that checks whether a value is a File instance. */\nexport function isFile(value: unknown): value is File\nexport function isFile<T extends File>(value: T): value is Extract<T, File>\nexport function isFile(value: unknown): value is File {\n  return typeof File !== 'undefined' && value instanceof File\n}\n", "import type { FieldType } from './ObjectTypeShape.js'\n\n/**\n * Checks whether a value matches the expected field type, with correct handling for arrays and nulls.\n * @param value - The value to check.\n * @param expectedType - The expected type string.\n * @returns True if the value matches the expected type.\n */\nexport const isType = (value: unknown, expectedType: FieldType) => {\n  const typeofValue = typeof value\n  switch (expectedType) {\n    case 'array': {\n      return Array.isArray(value)\n    }\n    case 'null': {\n      return value === null\n    }\n    case 'undefined': {\n      return value === undefined\n    }\n    case 'object': {\n      // nulls resolve to objects, so exclude them\n      if (value === null) {\n        return false\n      }\n      // arrays resolve to objects, so exclude them\n      return typeofValue === 'object' && !Array.isArray(value)\n    }\n    default: {\n      return typeofValue === expectedType\n    }\n  }\n}\n", "import type { AssertExErrorFunc, AssertExMessageFunc } from './types.ts'\n\n/**\n * Asserts that a value is defined (not undefined) and returns the value.\n * Throws an error if the value is undefined.\n *\n * @template T - The type of value to check\n * @param expr - Expression to be evaluated for being defined\n * @param messageFunc - Function that returns a message for the error if expression is undefined\n * @throws Error with the message returned by messageFunc\n * @returns The value of the expression (guaranteed to be defined)\n * @example\n * ```typescript\n * // Simple usage with a message function\n * const value = assertDefinedEx(possiblyUndefined, () => 'Value must be defined')\n *\n * // Using with type narrowing\n * const config: Config | undefined = loadConfig()\n * const safeConfig = assertDefinedEx(config, () => 'Config failed to load')\n * // safeConfig is now type Config (not Config | undefined)\n * ```\n */\nfunction assertDefinedEx<T>(expr: T | undefined, messageFunc?: AssertExMessageFunc<T>): T\n\n/**\n * Asserts that a value is defined (not undefined) and returns the value.\n * Throws a custom error if the value is undefined.\n *\n * @template T - The type of value to check\n * @template R - The type of error to throw\n * @param expr - Expression to be evaluated for being defined\n * @param errorFunc - Function that returns a custom error instance if expression is undefined\n * @throws Custom error returned by errorFunc\n * @returns The value of the expression (guaranteed to be defined)\n * @example\n * ```typescript\n * // Using with a custom error\n * const user = assertDefinedEx(getUser(), () => new UserNotFoundError('User not found'))\n * ```\n */\nfunction assertDefinedEx<T, R extends Error>(expr: T | undefined, errorFunc?: AssertExErrorFunc<T, R>): T\n\n/**\n * Implementation of assertDefinedEx that handles all overloads.\n *\n */\nfunction assertDefinedEx<T, R extends Error, P extends AssertExMessageFunc<T> | AssertExErrorFunc<T, R>>(\n  expr: T | undefined,\n  func?: P,\n): T {\n  if (expr !== undefined) return expr\n  if (typeof func === 'function') {\n    const errorOrMessage = func(expr)\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage\n  }\n  if (func !== undefined) {\n    throw new Error('Invalid assertDefinedEx usage: second argument must be a function or undefined')\n  }\n  throw new Error('Assertion failed: value is undefined')\n}\n\nexport { assertDefinedEx }\n", "import type { AssertExErrorFunc, AssertExMessageFunc } from './types.ts'\n\n/**\n * Asserts that an expression is truthy and returns the value.\n * Throws an error if the expression is falsy.\n *\n * @template T - The type of value to check\n * @param expr - Expression to be evaluated for truthiness\n * @param messageFunc - Function that returns a message for the error if expression is falsy\n * @throws Error with the message returned by messageFunc\n * @returns The value of the expression (guaranteed to be truthy)\n * @example\n * ```typescript\n * // Simple usage with a message function\n * const value = assertEx(possiblyFalsy, () => 'Value must be truthy')\n *\n * // Using with type narrowing\n * const config: Config | null = loadConfig()\n * const safeConfig = assertEx(config, () => 'Config failed to load')\n * // safeConfig is now type Config (not Config | null)\n * ```\n */\nfunction assertEx<T>(expr: T | null | undefined, messageFunc?: AssertExMessageFunc<T>): T\n\n/**\n * Asserts that an expression is truthy and returns the value.\n * Throws a custom error if the expression is falsy.\n *\n * @template T - The type of value to check\n * @template R - The type of error to throw\n * @param expr - Expression to be evaluated for truthiness\n * @param errorFunc - Function that returns a custom error instance if expression is falsy\n * @throws Custom error returned by errorFunc\n * @returns The value of the expression (guaranteed to be truthy)\n * @example\n * ```typescript\n * // Using with a custom error\n * const user = assertEx(getUser(), () => new UserNotFoundError('User not found'))\n * ```\n */\nfunction assertEx<T, R extends Error>(expr: T | null | undefined, errorFunc?: AssertExErrorFunc<T, R>): T\n\n/**\n * Implementation of assertEx that handles all overloads.\n */\nfunction assertEx<T, R extends Error, P extends AssertExMessageFunc<T> | AssertExErrorFunc<T, R>>(\n  expr: T | null | undefined,\n  func?: P,\n): T {\n  if (expr !== undefined && expr !== null && expr !== false && expr !== 0 && expr !== '' && expr !== 0n) return expr\n  if (typeof func === 'function') {\n    const errorOrMessage = func(expr)\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage\n  }\n  if (func !== undefined) {\n    throw new Error('Invalid assertEx usage: second argument must be a function or undefined')\n  }\n  throw new Error('Assertion failed')\n}\n\nexport { assertEx }\n", "import { assertDefinedEx } from '#assert'\nimport type {\n  AsTypeFunction,\n  StringOrAlertFunction, TypeCheck, TypeCheckConfig,\n  TypeCheckRequiredConfig,\n} from '#object-model'\nimport type { AnyNonPromise } from '#promise'\nimport { isPromise, isTruthy } from '#typeof'\n\n/**\n * Factory for creating type-narrowing 'as' functions that cast a value to T or return undefined.\n * Supports optional assertion messages and configuration for required/optional behavior.\n */\nexport const AsTypeFactory = {\n  create: <T extends AnyNonPromise>(typeCheck: TypeCheck<T>): AsTypeFunction<T> => {\n    const func = (\n      value: AnyNonPromise,\n      assertOrConfig?: StringOrAlertFunction<T> | TypeCheckConfig,\n      config?: TypeCheckConfig,\n    ): T | undefined => {\n      // when used as a predicate, it seems that the index is passed as the second parameter (filter,map)\n      const isPredicate = typeof assertOrConfig === 'number'\n      const resolvedAssert = isPredicate || (typeof assertOrConfig === 'object') ? undefined : assertOrConfig\n      const resolvedConfig = isPredicate ? undefined : typeof assertOrConfig === 'object' ? assertOrConfig : config\n\n      // only return undefined if not required\n      const isRequired = isTruthy((resolvedConfig as (TypeCheckRequiredConfig | undefined))?.required)\n      if (!isRequired && (value === undefined || value === null)) {\n        return undefined\n      }\n\n      if (isPromise(value)) {\n        throw new TypeError('un-awaited promises may not be sent to \"as\" functions')\n      }\n\n      const result = typeCheck(value, resolvedConfig) ? (value) : undefined\n\n      if (resolvedAssert !== undefined) {\n        const message = typeof resolvedAssert === 'function' ? resolvedAssert : () => resolvedAssert\n        return assertDefinedEx<T>(result, message)\n      }\n      return result\n    }\n    return func\n  },\n  createOptional: <T extends AnyNonPromise>(typeCheck: TypeCheck<T>) => {\n    const func = (value: AnyNonPromise): T | undefined => {\n      if (value === undefined || value === null) return undefined\n      if (isPromise(value)) {\n        throw new TypeError('un-awaited promises may not be sent to \"as\" functions')\n      }\n      return typeCheck(value) ? (value) : undefined\n    }\n    return func\n  },\n}\n", "import type { TypeCheck } from '#object-model'\nimport type { TypedObject } from '#typeof'\n\nimport { AsTypeFactory } from './AsTypeFactory.ts'\n\n/** Factory for creating type-narrowing functions for TypedObject types. */\nexport const AsObjectFactory = {\n  create: <T extends TypedObject>(typeCheck: TypeCheck<T>) => {\n    return AsTypeFactory.create<T>(typeCheck)\n  },\n  createOptional: <T extends TypedObject>(typeCheck: TypeCheck<T>) => {\n    return AsTypeFactory.createOptional<T>(typeCheck)\n  },\n}\n", "import type { AnyObject } from '#object-model'\nimport { isObject } from '#typeof'\n\nimport { AsObjectFactory } from './AsObjectFactory.ts'\n\n/** Type-narrowing function that casts a value to AnyObject if it is a plain object, or returns undefined. */\nexport const asAnyObject = (() => AsObjectFactory.create<AnyObject>(<T extends AnyObject>(obj: unknown): obj is T => isObject(obj)))()\n", "import type { AnyObject } from '#object-model'\n\n/**\n * Deeply merges two types into a new type.\n */\ntype DeepMerge<A, B> = {\n  [K in keyof A | keyof B]:\n  K extends keyof B\n    ? K extends keyof A\n      ? A[K] extends object\n        ? B[K] extends object\n          ? DeepMerge<A[K], B[K]>\n          : B[K]\n        : B[K]\n      : B[K]\n    : K extends keyof A\n      ? A[K]\n      : never;\n}\n\n/**\n * Merges multiple types into a new type.\n */\ntype MergeAll<T extends object[], R = {}>\n  = T extends [infer First extends object, ...infer Rest extends object[]]\n    ? MergeAll<Rest, DeepMerge<R, First>>\n    : R\n\n/**\n * Options for merging objects in the deep merge function.\n */\ninterface MergeOptions {\n  /**\n   * Strategy for merging arrays.\n   * - 'overwrite': Overwrites the array with the last object's value.\n   * - 'concat': Concatenates arrays from all objects.\n   * @default 'overwrite'\n   */\n  arrayStrategy?: 'overwrite' | 'concat'\n  /**\n   * Mutate the first object in the list instead of creating a new one.\n   * @default false\n   */\n  mutate?: boolean\n}\n\nconst isUnsafeKey = (key: string | symbol): boolean =>\n  typeof key === 'string' && ['__proto__', 'constructor', 'prototype'].includes(key)\n\nconst isPlainObject = (value: object): boolean => {\n  const prototype: object | null = Object.getPrototypeOf(value) as object | null\n  return prototype === Object.prototype || prototype === null\n}\n\nfunction merge<T extends AnyObject>(target: AnyObject, source?: AnyObject, options?: MergeOptions): T {\n  if (!source || typeof source !== 'object') return target as T\n\n  for (const key of Reflect.ownKeys(source)) {\n    if (isUnsafeKey(key)) {\n      continue\n    }\n    const value = source[key]\n    if (Array.isArray(value)) {\n      const targetValue = target[key]\n      target[key]\n      // If the value is an array, handle it based on the configured array strategy\n        = options?.arrayStrategy === 'concat' && Array.isArray(targetValue)\n          ? [...targetValue as unknown[], ...value as unknown[]]\n          : value\n    } else if (value !== null && typeof value === 'object' && isPlainObject(value)) {\n      const targetValue = target[key]\n      if (targetValue === undefined || targetValue === null || typeof targetValue !== 'object' || !isPlainObject(targetValue)) {\n        target[key] = {}\n      }\n      merge(target[key] as AnyObject, value as AnyObject, options)\n    } else {\n      // Overwrite with non-plain-object or primitive values\n      target[key] = value\n    }\n  }\n\n  return target as T\n}\n\n/**\n * Creates a deep merge function with the specified options.\n * @param options Options for merging.\n * @returns A deep merge function configured for the specified options.\n */\nexport function createDeepMerge(options: MergeOptions) {\n  return function deepMerge<T extends AnyObject[]>(...objects: T): MergeAll<T> {\n    const result = (options.mutate === true ? objects[0] ?? {} : {}) as MergeAll<T>\n    for (const obj of objects) {\n      merge(result, obj, options)\n    }\n    return result\n  }\n}\n\n/**\n * Deeply merges multiple objects into a new object.\n * @param objects Multiple objects to merge deeply.\n * The function merges properties from all objects into a new object.\n * If a property exists in multiple objects, the last object's value will be used.\n * If a property is an object, it will be merged recursively.\n * If a property is an array, it will be overwritten by the last object's value.\n * If a property is a primitive value, it will be overwritten by the last object's value.\n * If a property is undefined in the source, it will be skipped.\n * If a property is a symbol, it will be merged as well.\n * @returns A new object with the merged properties.\n */\nexport const deepMerge = createDeepMerge({ arrayStrategy: 'overwrite', mutate: false })\n", "import type { TypeCheck, TypeCheckConfig } from '#object-model'\nimport {\n  isObject, isTruthy,\n  type ObjectTypeShape, type TypedObject,\n} from '#typeof'\nimport { isType } from '#typeof'\n\ninterface ConsoleLogger {\n  warn: (...data: unknown[]) => void\n}\n\ndeclare const console: ConsoleLogger\n\n/** Configuration options for object type checking. */\nexport interface ObjectTypeConfig extends TypeCheckConfig {}\n\n/** Factory class for creating type-guard functions that validate objects against a given shape and optional additional checks. */\nexport class IsObjectFactory<T extends TypedObject> {\n  /**\n   * Creates a type-guard function that validates an object matches the given shape and passes additional checks.\n   * @param shape - An optional map of property names to expected types.\n   * @param additionalChecks - Optional extra type-check functions to run after shape validation.\n   * @returns A type-guard function for type T.\n   */\n  create(shape?: ObjectTypeShape, additionalChecks?: TypeCheck<TypedObject>[]): TypeCheck<T> {\n    return (obj: unknown, config?: TypeCheckConfig | number): obj is T => {\n      if (!isObject(obj)) {\n        return false\n      }\n      const log = (typeof config === 'object') ? config.log : undefined\n      return (\n        // do primary check\n        Object.entries(shape ?? {}).filter(([key, type]) => {\n          const isResult = isType((obj as Record<string, unknown>)[key], type)\n          if (!isResult && isTruthy(log)) {\n            const logger = typeof log === 'object' ? log : console\n            logger.warn(`isType Failed: ${key}: ${type}`)\n          }\n          return !isResult\n        }).length === 0\n        // perform additional checks\n        // eslint-disable-next-line unicorn/no-array-reduce\n        && (additionalChecks?.reduce((prev, check) => prev && check(obj, { log }), true) ?? true)\n      )\n    }\n  }\n}\n", "import * as z from 'zod/mini'\n\nimport {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '#zod'\n\nconst JsonArrayZod = z.array(z.lazy(() => JsonValueZod))\n\n// Define recursive JSON value schema\nconst JsonValueZod: z.ZodMiniType<unknown> = z.lazy(() =>\n  z.union([\n    z.string(),\n    z.number(),\n    z.boolean(),\n    z.null(),\n    z.array(JsonValueZod),\n    z.record(z.string(), JsonValueZod), // object with string keys and JSON values\n  ]))\n\n// JSON object schema \u2014 top-level must be an object\n/** Zod schema for a JSON object with string keys and recursive JSON values. */\nexport const JsonObjectZod = z.record(z.string(), JsonValueZod)\n\n// TypeScript type for reference\n/** A recursive JSON value: string, number, boolean, null, array, or object. */\nexport type JsonValue = z.infer<typeof JsonValueZod>\n/** A JSON object with string keys and JSON values. */\nexport type JsonObject = z.infer<typeof JsonObjectZod>\n/** A JSON array containing JSON values. */\nexport type JsonArray = z.infer<typeof JsonArrayZod>\n\n/** Type guard that checks if a value is a valid JSON value. */\nexport const isJsonValue = zodIsFactory(JsonValueZod)\n/** Casts a value to JsonValue or returns undefined if it does not conform. */\nexport const asJsonValue = zodAsFactory(JsonValueZod, 'asJsonValue')\n/** Parses a value into a JsonValue, throwing if it does not conform. */\nexport const toJsonValue = zodToFactory(JsonValueZod, 'toJsonValue')\n\n/** Type guard that checks if a value is a valid JSON array. */\nexport const isJsonArray = zodIsFactory(JsonArrayZod)\n/** Casts a value to JsonArray or returns undefined if it does not conform. */\nexport const asJsonArray = zodAsFactory(JsonArrayZod, 'asJsonArray')\n/** Parses a value into a JsonArray, throwing if it does not conform. */\nexport const toJsonArray = zodToFactory(JsonArrayZod, 'toJsonArray')\n\n/** Type guard that checks if a value is a valid JSON object. */\nexport const isJsonObject = zodIsFactory(JsonObjectZod)\n/** Casts a value to JsonObject or returns undefined if it does not conform. */\nexport const asJsonObject = zodAsFactory(JsonObjectZod, 'asJsonObject')\n/** Parses a value into a JsonObject, throwing if it does not conform. */\nexport const toJsonObject = zodToFactory(JsonObjectZod, 'toJsonObject')\n", "import * as z from 'zod/v4/core'\n\nimport type { AssertConfig } from '#error'\nimport { assertError } from '#error'\n\nimport type { ZodFactoryConfig } from './Config.ts'\n\nconst formatZodValue = (value: unknown): string => {\n  const json = JSON.stringify(value)\n  return json ?? String(value)\n}\n\n/**\n * Creates a function that validates a value against a zod schema and returns it with a narrowed type.\n * When called without an assert config, returns undefined on failure. When called with an assert config, throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns A function that validates and narrows the type of a value\n */\nexport function zodAsFactory<TZod>(zod: z.$ZodType<TZod>, name: string) {\n  function asFunc<T>(value: T): (T & TZod) | undefined\n  function asFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function asFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    const result = z.safeParse(zod, value)\n    if (result.success) {\n      return value as (T & TZod)\n    }\n    if (assert !== undefined) {\n      let assertConfig: AssertConfig\n      switch (typeof assert) {\n        case 'string': {\n          assertConfig = `[${name}][${formatZodValue(value)}] ${assert}`\n          break\n        }\n        case 'object': {\n          assertConfig = `[${name}][${assert.name}][${formatZodValue(value)}] ${result.error.message}`\n          break\n        }\n        case 'boolean': {\n          assertConfig = `[${name}][${formatZodValue(value)}] ${result.error.message}`\n          break\n        }\n        case 'function': {\n          assertConfig = assert(value, result.error.message) as AssertConfig\n          break\n        }\n      }\n      return assertError(value, assertConfig, result.error.message)\n    }\n  }\n\n  return asFunc\n}\n", "import { isString, isUndefined } from '#typeof'\n\ntype AssertCallback = (value: unknown, message: string) => string | boolean\n\n/** Configuration for assertion behavior: a static message string, a boolean toggle, or a callback. */\nexport type AssertConfig = string | AssertCallback | boolean\n\n/**\n * Throws an Error based on the assert configuration when a value fails validation.\n * @param value - The value being validated\n * @param assert - Assertion config controlling the error message\n * @param defaultMessage - Fallback message if no custom message is provided\n */\nexport const assertError = (value: unknown, assert: AssertConfig | undefined, defaultMessage: string) => {\n  if (!isUndefined(assert)) {\n    const assertString\n      = typeof assert === 'string'\n        ? assert\n        : typeof assert === 'boolean'\n          ? defaultMessage\n          : assert(value, defaultMessage)\n    if (isString(assertString) || assertString) {\n      throw new Error(assertString === true ? defaultMessage : assertString)\n    }\n  }\n  // eslint-disable-next-line unicorn/no-useless-undefined\n  return undefined\n}\n", "import * as z from 'zod/v4/core'\n\n/**\n * Creates a type guard function that checks if a value matches a zod schema.\n * @param zod - The zod schema to validate against\n * @returns A type guard function that returns true if the value passes validation\n */\nexport function zodIsFactory<TZod>(zod: z.$ZodType<TZod>) {\n  return <T>(value: T): value is T & TZod => z.safeParse(zod, value).success\n}\n", "import type * as z from 'zod/v4/core'\n\nimport { isDefined } from '#typeof'\n\nimport type { ZodFactoryConfig } from './Config.ts'\nimport { zodAsFactory } from './zodAsFactory.ts'\n\n/**\n * Creates a function that converts a value to the zod schema type, delegating to `zodAsFactory` internally.\n * Provides overloads for optional assertion: without assert config returns undefined on failure, with assert config throws on failure.\n * @param zod - The zod schema to validate against\n * @param name - A name used in error messages for identification\n * @returns A function that validates and converts a value to the schema type\n */\nexport function zodToFactory<TZod>(zod: z.$ZodType<TZod>, name: string) {\n  const as = zodAsFactory<TZod>(zod, name)\n  function toFunc<T>(value: T): (T & TZod) | undefined\n  function toFunc<T>(value: T, assert: ZodFactoryConfig): (T & TZod)\n  function toFunc<T>(value: T, assert?: ZodFactoryConfig): (T & TZod) | undefined {\n    if (isDefined(assert)) {\n      return as(value, assert)\n    }\n    return as(value)\n  }\n  return toFunc\n}\n", "import type { EmptyObject } from './EmptyObject.ts'\nimport type { StringKeyObject } from './StringKeyObject.ts'\n\n/** Abstract base class that wraps an object and provides typed access to it. */\nexport abstract class ObjectWrapper<T extends EmptyObject = EmptyObject> {\n  readonly obj: T\n  constructor(obj: T) {\n    this.obj = obj\n  }\n\n  protected get stringKeyObj() {\n    return this.obj as StringKeyObject\n  }\n}\n", "import { assertEx } from '#assert'\n\nimport type { EmptyObject } from './EmptyObject.ts'\nimport type { JsonObject } from './JsonObject.ts'\nimport type { DeepOmitStartsWith } from './OmitStartsWith.ts'\n\n/** A predicate function used to determine which properties to omit from an object. */\nexport type OmitByPredicate<T extends EmptyObject = Record<string, unknown>> = (value: T[keyof T], key: keyof T) => boolean\n\nconst omitByArray = <T>(\n  obj: T[],\n  predicate: OmitByPredicate,\n  maxDepth: number,\n): T[] => {\n  return obj.map((value) => {\n    return (value !== null && typeof value === 'object') ? omitBy(value, predicate, maxDepth) : value\n  }) as T[]\n}\n\nconst omitByObject = <T extends EmptyObject>(\n  obj: T,\n  predicate: OmitByPredicate,\n  maxDepth: number,\n): Partial<T> => {\n  const result: JsonObject = {}\n\n  for (const key of Object.keys(obj)) {\n    const value = obj[key as keyof T]\n    if (!predicate(value, key)) {\n      result[key] = ((value !== null && typeof value === 'object') ? omitBy(value, predicate, maxDepth - 1) : value)\n    }\n  }\n\n  return result as T\n}\n\n/**\n * Creates a new object excluding properties that satisfy the predicate, with optional recursive depth.\n * @param obj - The source object to omit properties from.\n * @param predicate - A function that returns true for properties to exclude.\n * @param maxDepth - Maximum recursion depth for nested objects.\n * @returns A partial copy of the object without matching properties.\n */\nexport const omitBy = <T extends EmptyObject>(\n  obj: T,\n  predicate: OmitByPredicate,\n  maxDepth = 1,\n): Partial<T> => {\n  if (maxDepth <= 0) {\n    return obj\n  }\n\n  return Array.isArray(obj) ? omitByArray(obj, predicate, maxDepth - 1) as T : omitByObject(obj, predicate, maxDepth - 1)\n}\n\nconst omitByPrefixPredicate = (prefix: string) => (_: unknown, key: string) => {\n  assertEx(typeof key === 'string', () => `Invalid key type [${key}, ${typeof key}]`)\n  return key.startsWith(prefix)\n}\n\n/**\n * Omits all properties whose keys start with the given prefix, recursively through nested objects.\n * @param payload - The source object.\n * @param prefix - The string prefix to match keys against.\n * @param maxDepth - Maximum recursion depth.\n * @returns A new object without properties that have matching prefixed keys.\n */\nexport const omitByPrefix = <T extends EmptyObject, P extends string>(payload: T, prefix: P, maxDepth = 100): DeepOmitStartsWith<T, P> => {\n  return omitBy(payload, omitByPrefixPredicate(prefix), maxDepth) as unknown as DeepOmitStartsWith<T, P>\n}\n", "import { assertEx } from '#assert'\n\nimport type { EmptyObject } from './EmptyObject.ts'\nimport type { JsonObject } from './JsonObject.ts'\nimport type { DeepPickStartsWith } from './PickStartsWith.ts'\n\n/** A predicate function used to determine which properties to pick from an object. */\nexport type PickByPredicate<T extends EmptyObject = Record<string, unknown>> = (value: T[keyof T], key: keyof T) => boolean\n\nconst pickByArray = <T>(\n  obj: T[],\n  predicate: PickByPredicate,\n  maxDepth: number,\n): T[] => {\n  return obj.map((value) => {\n    return (value !== null && typeof value === 'object') ? pickBy(value, predicate, maxDepth) : value\n  }) as T[]\n}\n\nconst pickByObject = <T extends EmptyObject>(\n  obj: T,\n  predicate: PickByPredicate,\n  maxDepth: number,\n): Partial<T> => {\n  const result: JsonObject = {}\n\n  for (const key of Object.keys(obj)) {\n    const value = obj[key as keyof T]\n    if (predicate(value, key)) {\n      result[key] = ((value !== null && typeof value === 'object') ? pickBy(value, predicate, maxDepth - 1) : value)\n    }\n  }\n\n  return result as T\n}\n\n/**\n * Creates a new object containing only the properties that satisfy the predicate, with optional recursive depth.\n * @param obj - The source object to pick properties from.\n * @param predicate - A function that returns true for properties to include.\n * @param maxDepth - Maximum recursion depth for nested objects.\n * @returns A partial copy of the object with only matching properties.\n */\nexport const pickBy = <T extends EmptyObject>(\n  obj: T,\n  predicate: PickByPredicate,\n  maxDepth = 1,\n): Partial<T> => {\n  if (maxDepth <= 0) {\n    return obj\n  }\n\n  return Array.isArray(obj) ? pickByArray(obj, predicate, maxDepth - 1) as T : pickByObject(obj, predicate, maxDepth - 1)\n}\n\nconst pickByPrefixPredicate = (prefix: string) => (_: unknown, key: string) => {\n  assertEx(typeof key === 'string', () => `Invalid key type [${key}, ${typeof key}]`)\n  return key.startsWith(prefix)\n}\n\n/**\n * Picks all properties whose keys start with the given prefix, recursively through nested objects.\n * @param payload - The source object.\n * @param prefix - The string prefix to match keys against.\n * @param maxDepth - Maximum recursion depth.\n * @returns A new object containing only properties with matching prefixed keys.\n */\nexport const pickByPrefix = <T extends EmptyObject, P extends string>(payload: T, prefix: P, maxDepth = 100): DeepPickStartsWith<T, P> => {\n  return pickBy(payload, pickByPrefixPredicate(prefix), maxDepth) as unknown as DeepPickStartsWith<T, P>\n}\n", "import type { EmptyObject } from './EmptyObject.ts'\n\n/**\n * Returns a shallow copy of the object with the specified fields removed.\n * @param obj - The source object.\n * @param fields - An array of keys to remove.\n * @returns A new object without the specified fields.\n */\nexport const removeFields = <T extends EmptyObject, K extends keyof T>(obj: T, fields: K[]): Omit<T, K> => {\n  const clone = { ...obj }\n  for (const field of fields) {\n    delete clone[field]\n  }\n  return clone\n}\n", "import type {\n  JsonArray, JsonObject, JsonValue,\n} from './JsonObject.ts'\n\n/**\n * Converts an array to a JSON-safe array, handling circular references and depth limits.\n * @param value - The array to convert.\n * @param cycleList - Tracks visited objects to detect circular references.\n * @param maxDepth - Maximum recursion depth before truncating.\n * @returns A JSON-safe array representation.\n */\nexport const toSafeJsonArray = (value: unknown[], cycleList?: unknown[], maxDepth = 3): JsonArray => {\n  return value.map(item => toSafeJsonValue(item, cycleList, maxDepth))\n}\n\n/**\n * Converts an object to a JSON-safe object, handling circular references and depth limits.\n * @param value - The object to convert.\n * @param cycleList - Tracks visited objects to detect circular references.\n * @param maxDepth - Maximum recursion depth before truncating.\n * @returns A JSON-safe object representation.\n */\nexport const toSafeJsonObject = (value: object, cycleList?: unknown[], maxDepth = 3): JsonObject => {\n  const result: JsonObject = {}\n  for (const [key, entry] of Object.entries(value)) {\n    result[key] = entry === undefined ? '[Undefined]' : toSafeJsonValue(entry, cycleList, maxDepth)\n  }\n  return result\n}\n\n/**\n * Converts an unknown value to a JSON-safe value, replacing circular references with '[Circular]' and\n * non-JSON types with descriptive placeholder strings.\n * @param value - The value to convert.\n * @param cycleList - Tracks visited objects to detect circular references.\n * @param maxDepth - Maximum recursion depth before truncating with '[MaxDepth]'.\n * @returns A JSON-safe representation of the value.\n */\nexport const toSafeJsonValue = (value: unknown, cycleList?: unknown[], maxDepth = 3): JsonValue => {\n  if (maxDepth <= 0 && typeof value === 'object') {\n    return '[MaxDepth]'\n  }\n  if (cycleList?.includes(value) === true) {\n    return '[Circular]'\n  }\n  switch (typeof value) {\n    case 'string':\n    case 'boolean':\n    case 'number': {\n      return value\n    }\n    case 'object': {\n      if (value === null) {\n        return null\n      }\n      const newCycleList = cycleList ?? []\n      newCycleList.push(value)\n      if (Array.isArray(value)) {\n        return toSafeJsonArray(value, newCycleList, maxDepth - 1)\n      }\n      return toSafeJsonObject(value, newCycleList, maxDepth - 1)\n    }\n    default: {\n      return `[${typeof value}]`\n    }\n  }\n}\n\n/**\n * Converts a value to a pretty-printed JSON string, safely handling circular references and non-JSON types.\n * @param value - The value to serialize.\n * @param maxDepth - Maximum recursion depth.\n * @returns A formatted JSON string.\n */\nexport const toSafeJsonString = (value: unknown, maxDepth = 3) => {\n  return JSON.stringify(toSafeJson(value, maxDepth), null, 2)\n}\n\n/**\n * Converts a value to a JSON-safe representation, handling circular references and non-serializable types.\n * @param value - The value to convert.\n * @param maxDepth - Maximum recursion depth.\n * @returns A JSON-safe value.\n */\nexport const toSafeJson = (value: unknown, maxDepth = 3): JsonValue => {\n  return toSafeJsonValue(value, undefined, maxDepth)\n}\n", "import type { AnyObject } from '#object-model'\nimport type { Promisable } from '#promise'\n\nimport type { EmptyObject } from './EmptyObject.ts'\nimport { ObjectWrapper } from './ObjectWrapper.ts'\n\n/** Interface for validating objects and returning any errors found. */\nexport interface Validator<T extends EmptyObject = AnyObject> {\n  validate(payload: T): Promisable<Error[]>\n}\n\n/** Abstract base class for validators that wraps a partial object and provides a validation method. */\nexport abstract class ValidatorBase<T extends EmptyObject = AnyObject> extends ObjectWrapper<Partial<T>> implements Validator<T> {\n  abstract validate(payload: T): Promisable<Error[]>\n}\n"],
+  "mappings": "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",
+  "names": ["deepMerge", "z", "z"]
+}

package/dist/neutral/object.model.d.ts

@@ -1 +1,2 @@
-export type * from '../_pkg/object/neutral/model.ts'
+export type * from './modules/object/model.js';
+//# sourceMappingURL=object.model.d.ts.map

package/dist/neutral/object.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.model.d.ts","sourceRoot":"","sources":["../../src/object.model.ts"],"names":[],"mappings":"AAAA,mBAAmB,eAAe,CAAA"}

package/dist/neutral/object.model.mjs

@@ -1 +1 @@
-export * from '../_pkg/object/neutral/model.mjs'
+//# sourceMappingURL=object.model.mjs.map

package/dist/neutral/object.model.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/neutral/profile.d.ts

@@ -1 +1,2 @@
-export * from '../_pkg/profile/neutral/index.ts'
+export * from './modules/profile/index.js';
+//# sourceMappingURL=profile.d.ts.map

package/dist/neutral/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/profile.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}