@duplojs/lang 0.0.0

package/dist/object/discriminateEntryKey.cjs

@@ -0,0 +1,11 @@
+//#region scripts/object/discriminateEntryKey.ts
+function discriminateEntryKey(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (entry) => discriminateEntryKey(entry, predicate);
+	}
+	const [entry, predicate] = args;
+	return predicate(entry[0]);
+}
+//#endregion
+exports.discriminateEntryKey = discriminateEntryKey;

package/dist/object/discriminateEntryKey.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from '../common';
+export declare function discriminateEntryKey<GenericEntry extends readonly [string, unknown], GenericPredicateEntryKey extends GenericEntry[0]>(predicate: (key: GenericEntry[0]) => key is GenericPredicateEntryKey): (entry: GenericEntry) => entry is Extract<DCommon.CleanObjectEntry<GenericEntry>, [
+    GenericPredicateEntryKey,
+    unknown
+]>;
+export declare function discriminateEntryKey<GenericEntry extends readonly [string, unknown]>(predicate: (key: GenericEntry[0]) => boolean): (entry: GenericEntry) => boolean;
+export declare function discriminateEntryKey<GenericEntry extends readonly [string, unknown], GenericPredicateEntryKey extends GenericEntry[0]>(entry: GenericEntry, predicate: (key: GenericEntry[0]) => key is GenericPredicateEntryKey): entry is Extract<DCommon.CleanObjectEntry<GenericEntry>, [
+    GenericPredicateEntryKey,
+    unknown
+]>;
+export declare function discriminateEntryKey<GenericEntry extends readonly [string, unknown]>(entry: GenericEntry, predicate: (key: GenericEntry[0]) => boolean): boolean;

package/dist/object/discriminateEntryKey.mjs

@@ -0,0 +1,11 @@
+//#region scripts/object/discriminateEntryKey.ts
+function discriminateEntryKey(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (entry) => discriminateEntryKey(entry, predicate);
+	}
+	const [entry, predicate] = args;
+	return predicate(entry[0]);
+}
+//#endregion
+export { discriminateEntryKey };

package/dist/object/discriminateEntryValue.cjs

@@ -0,0 +1,11 @@
+//#region scripts/object/discriminateEntryValue.ts
+function discriminateEntryValue(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (entry) => discriminateEntryValue(entry, predicate);
+	}
+	const [entry, predicate] = args;
+	return predicate(entry[1]);
+}
+//#endregion
+exports.discriminateEntryValue = discriminateEntryValue;

package/dist/object/discriminateEntryValue.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from '../common';
+export declare function discriminateEntryValue<GenericEntry extends readonly [string, unknown], GenericPredicateEntryValue extends GenericEntry[1]>(predicate: (value: GenericEntry[1]) => value is GenericPredicateEntryValue): (entry: GenericEntry) => entry is Extract<DCommon.CleanObjectEntry<GenericEntry>, [
+    string,
+    GenericPredicateEntryValue
+]>;
+export declare function discriminateEntryValue<GenericEntry extends readonly [string, unknown]>(predicate: (value: GenericEntry[1]) => boolean): (entry: GenericEntry) => boolean;
+export declare function discriminateEntryValue<GenericEntry extends readonly [string, unknown], GenericPredicateEntryValue extends GenericEntry[1]>(entry: GenericEntry, predicate: (value: GenericEntry[1]) => value is GenericPredicateEntryValue): entry is Extract<DCommon.CleanObjectEntry<GenericEntry>, [
+    string,
+    GenericPredicateEntryValue
+]>;
+export declare function discriminateEntryValue<GenericEntry extends readonly [string, unknown]>(entry: GenericEntry, predicate: (value: GenericEntry[1]) => boolean): boolean;

package/dist/object/discriminateEntryValue.mjs

@@ -0,0 +1,11 @@
+//#region scripts/object/discriminateEntryValue.ts
+function discriminateEntryValue(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (entry) => discriminateEntryValue(entry, predicate);
+	}
+	const [entry, predicate] = args;
+	return predicate(entry[1]);
+}
+//#endregion
+export { discriminateEntryValue };

package/dist/object/entries.cjs

@@ -0,0 +1,13 @@
+const require_base = require("../kind/base.cjs");
+//#region scripts/object/entries.ts
+function entries(object) {
+	const result = [];
+	for (const key in object) if (!require_base.isRuntimeKey(key)) result.push([key, object[key]]);
+	return result;
+}
+/**
+* @deprecated Not ignore kind key.
+*/
+entries.unsafe = Object.entries;
+//#endregion
+exports.entries = entries;

package/dist/object/entries.d.ts

@@ -0,0 +1,15 @@
+import type * as DString from '../string';
+import type * as DCommon from '../common';
+export type GetEntry<GenericKey extends DCommon.ObjectKey, GenericValue extends unknown> = GenericValue extends any ? GenericKey extends string | number ? [`${GenericKey}`, GenericValue] : never : never;
+export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? [DString.Number, GenericObject[number]][] : DCommon.IsEqual<GenericObject, object> extends true ? [string, DCommon.AnyValue][] : ({
+    [Prop in keyof GenericObject]-?: GetEntry<Prop, GenericObject[Prop]>;
+}[keyof GenericObject]) extends infer InferredResult extends DCommon.ObjectEntry ? DCommon.IsEqual<InferredResult, never> extends true ? [] : InferredResult[] : never;
+export declare function entries<GenericObject extends object>(object: GenericObject): DCommon.SimplifyTopLevel<GetEntries<GenericObject>>;
+export declare namespace entries {
+    var unsafe: {
+        <T>(o: {
+            [s: string]: T;
+        } | ArrayLike<T>): [string, T][];
+        (o: {}): [string, any][];
+    };
+}

package/dist/object/entries.mjs

@@ -0,0 +1,13 @@
+import { isRuntimeKey } from "../kind/base.mjs";
+//#region scripts/object/entries.ts
+function entries(object) {
+	const result = [];
+	for (const key in object) if (!isRuntimeKey(key)) result.push([key, object[key]]);
+	return result;
+}
+/**
+* @deprecated Not ignore kind key.
+*/
+entries.unsafe = Object.entries;
+//#endregion
+export { entries };

package/dist/object/entry.cjs

@@ -0,0 +1,6 @@
+//#region scripts/object/entry.ts
+function entry(key, value) {
+	return [key, value];
+}
+//#endregion
+exports.entry = entry;

package/dist/object/entry.d.ts

@@ -0,0 +1,2 @@
+import type * as DCommon from '../common';
+export declare function entry<GenericKey extends DCommon.ObjectKey, GenericValue extends unknown>(key: GenericKey, value: GenericValue): readonly [GenericKey, GenericValue];

package/dist/object/entry.mjs

@@ -0,0 +1,6 @@
+//#region scripts/object/entry.ts
+function entry(key, value) {
+	return [key, value];
+}
+//#endregion
+export { entry };

package/dist/object/fromEntries.cjs

@@ -0,0 +1,6 @@
+//#region scripts/object/fromEntries.ts
+function fromEntries(entries) {
+	return Object.fromEntries(entries);
+}
+//#endregion
+exports.fromEntries = fromEntries;

package/dist/object/fromEntries.d.ts

@@ -0,0 +1,8 @@
+import type * as DCommon from '../common';
+type FromEntriesOutput<GenericEntry extends DCommon.ObjectEntry> = DCommon.UnionContain<DCommon.ObjectKey, GenericEntry[0]> extends true ? DCommon.SimplifyTopLevel<{
+    [Entry in GenericEntry as Entry[0]]: Entry[1];
+}> : DCommon.SimplifyTopLevel<{
+    [Entry in GenericEntry as Entry[0]]?: Entry[1];
+}>;
+export declare function fromEntries<GenericKey extends DCommon.ObjectKey, const GenericEntry extends readonly [GenericKey, unknown]>(entries: Iterable<GenericEntry>): FromEntriesOutput<GenericEntry>;
+export {};

package/dist/object/fromEntries.mjs

@@ -0,0 +1,6 @@
+//#region scripts/object/fromEntries.ts
+function fromEntries(entries) {
+	return Object.fromEntries(entries);
+}
+//#endregion
+export { fromEntries };

package/dist/object/getDeepProperty.cjs

@@ -0,0 +1,18 @@
+//#region scripts/object/getDeepProperty.ts
+const regexExtractProperty = /([^.]*)(?:\.([^]*))?/;
+function getDeepPropertyImplementation(input, path) {
+	const [, first, rest] = path.match(regexExtractProperty);
+	const currentValue = input[first];
+	if (rest) return getDeepPropertyImplementation(currentValue, rest);
+	return currentValue;
+}
+function getDeepProperty(...args) {
+	if (args.length === 1) {
+		const [path] = args;
+		return (input) => getDeepProperty(input, path);
+	}
+	const [input, path] = args;
+	return getDeepPropertyImplementation(input, path);
+}
+//#endregion
+exports.getDeepProperty = getDeepProperty;

package/dist/object/getDeepProperty.d.ts

@@ -0,0 +1,6 @@
+import { FlatObject, GetPropsWithValueExtends } from './types';
+import type * as DCommon from '../common';
+type ObjectProjection<GenericInput extends object> = FlatObject<GenericInput> extends infer InferredResult extends object ? Omit<Pick<InferredResult, GetPropsWithValueExtends<InferredResult, DCommon.EligibleEqual>>, `${string}[${string}]${string}`> : never;
+export declare function getDeepProperty<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection>(path: GenericPath): (input: GenericInput) => GenericObjectProjection[GenericPath];
+export declare function getDeepProperty<GenericInput extends object, GenericObjectProjection extends ObjectProjection<GenericInput>, GenericPath extends keyof GenericObjectProjection>(input: GenericInput, path: GenericPath): GenericObjectProjection[GenericPath];
+export {};

package/dist/object/getDeepProperty.mjs

@@ -0,0 +1,18 @@
+//#region scripts/object/getDeepProperty.ts
+const regexExtractProperty = /([^.]*)(?:\.([^]*))?/;
+function getDeepPropertyImplementation(input, path) {
+	const [, first, rest] = path.match(regexExtractProperty);
+	const currentValue = input[first];
+	if (rest) return getDeepPropertyImplementation(currentValue, rest);
+	return currentValue;
+}
+function getDeepProperty(...args) {
+	if (args.length === 1) {
+		const [path] = args;
+		return (input) => getDeepProperty(input, path);
+	}
+	const [input, path] = args;
+	return getDeepPropertyImplementation(input, path);
+}
+//#endregion
+export { getDeepProperty };

package/dist/object/getProperty.cjs

@@ -0,0 +1,11 @@
+//#region scripts/object/getProperty.ts
+function getProperty(...args) {
+	if (args.length === 1) {
+		const [key] = args;
+		return (object) => getProperty(object, key);
+	}
+	const [object, key] = args;
+	return object[key];
+}
+//#endregion
+exports.getProperty = getProperty;

package/dist/object/getProperty.d.ts

@@ -0,0 +1,7 @@
+import { PartialKeys, UnionObjectToIntersection } from './types';
+type MergeTopLevelUnionObject<GenericObject extends object, GenericFullObjectKeys extends keyof UnionObjectToIntersection<GenericObject> = keyof UnionObjectToIntersection<GenericObject>> = PartialKeys<{
+    [Prop in GenericFullObjectKeys]: (GenericObject extends object ? Prop extends keyof GenericObject ? GenericObject[Prop] : never : never);
+}, Exclude<GenericFullObjectKeys, keyof GenericObject>>;
+export declare function getProperty<GenericObject extends object, GenericFullObject extends MergeTopLevelUnionObject<GenericObject>, GenericKey extends keyof GenericFullObject>(key: GenericKey): (object: GenericObject) => GenericFullObject[GenericKey];
+export declare function getProperty<GenericObject extends object, GenericFullObject extends MergeTopLevelUnionObject<GenericObject>, GenericKey extends keyof GenericFullObject>(obj: GenericObject, key: GenericKey): GenericFullObject[GenericKey];
+export {};

package/dist/object/getProperty.mjs

@@ -0,0 +1,11 @@
+//#region scripts/object/getProperty.ts
+function getProperty(...args) {
+	if (args.length === 1) {
+		const [key] = args;
+		return (object) => getProperty(object, key);
+	}
+	const [object, key] = args;
+	return object[key];
+}
+//#endregion
+export { getProperty };

package/dist/object/hasKeys.cjs

@@ -0,0 +1,14 @@
+//#region scripts/object/hasKeys.ts
+function hasKeys(...args) {
+	if (args.length === 1) {
+		const [keys] = args;
+		return (partialObject) => hasKeys(partialObject, keys);
+	}
+	const [partialObject, keys] = args;
+	const formattedKey = Array.isArray(keys) ? keys : [keys];
+	const indexedPartialObject = partialObject;
+	for (const key of formattedKey) if (indexedPartialObject[key] === void 0) return false;
+	return true;
+}
+//#endregion
+exports.hasKeys = hasKeys;

package/dist/object/hasKeys.d.ts

@@ -0,0 +1,3 @@
+import { RequiredKeys } from './types';
+export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(keys: GenericKeys | readonly GenericKeys[]): (partialObject: GenericObject) => partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;
+export declare function hasKeys<GenericObject extends object, GenericKeys extends keyof GenericObject>(partialObject: GenericObject, keys: GenericKeys | readonly GenericKeys[]): partialObject is RequiredKeys<GenericObject, NoInfer<GenericKeys>>;

package/dist/object/hasKeys.mjs

@@ -0,0 +1,14 @@
+//#region scripts/object/hasKeys.ts
+function hasKeys(...args) {
+	if (args.length === 1) {
+		const [keys] = args;
+		return (partialObject) => hasKeys(partialObject, keys);
+	}
+	const [partialObject, keys] = args;
+	const formattedKey = Array.isArray(keys) ? keys : [keys];
+	const indexedPartialObject = partialObject;
+	for (const key of formattedKey) if (indexedPartialObject[key] === void 0) return false;
+	return true;
+}
+//#endregion
+export { hasKeys };

package/dist/object/index.cjs

@@ -0,0 +1,74 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_assign = require("./assign.cjs");
+const require_countKeys = require("./countKeys.cjs");
+const require_getDeepProperty = require("./getDeepProperty.cjs");
+const require_deepDiscriminate = require("./deepDiscriminate.cjs");
+const require_discriminate = require("./discriminate.cjs");
+const require_discriminateEntryKey = require("./discriminateEntryKey.cjs");
+const require_discriminateEntryValue = require("./discriminateEntryValue.cjs");
+const require_entries = require("./entries.cjs");
+const require_entry = require("./entry.cjs");
+const require_fromEntries = require("./fromEntries.cjs");
+const require_getProperty = require("./getProperty.cjs");
+const require_hasKeys = require("./hasKeys.cjs");
+const require_isSimple = require("./isSimple.cjs");
+const require_keys = require("./keys.cjs");
+const require_omit = require("./omit.cjs");
+const require_override = require("./override.cjs");
+const require_pick = require("./pick.cjs");
+const require_to = require("./to.cjs");
+const require_transformProperties = require("./transformProperties.cjs");
+const require_transformProperty = require("./transformProperty.cjs");
+const require_values = require("./values.cjs");
+//#region scripts/object/index.ts
+var object_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	assign: () => require_assign.assign,
+	countKeys: () => require_countKeys.countKeys,
+	deepDiscriminate: () => require_deepDiscriminate.deepDiscriminate,
+	discriminate: () => require_discriminate.discriminate,
+	discriminateEntryKey: () => require_discriminateEntryKey.discriminateEntryKey,
+	discriminateEntryValue: () => require_discriminateEntryValue.discriminateEntryValue,
+	entries: () => require_entries.entries,
+	entry: () => require_entry.entry,
+	fromEntries: () => require_fromEntries.fromEntries,
+	getDeepProperty: () => require_getDeepProperty.getDeepProperty,
+	getProperty: () => require_getProperty.getProperty,
+	hasKeys: () => require_hasKeys.hasKeys,
+	isSimple: () => require_isSimple.isSimple,
+	keys: () => require_keys.keys,
+	omit: () => require_omit.omit,
+	override: () => require_override.override,
+	pick: () => require_pick.pick,
+	to: () => require_to.to,
+	transformProperties: () => require_transformProperties.transformProperties,
+	transformProperty: () => require_transformProperty.transformProperty,
+	values: () => require_values.values
+});
+//#endregion
+exports.assign = require_assign.assign;
+exports.countKeys = require_countKeys.countKeys;
+exports.deepDiscriminate = require_deepDiscriminate.deepDiscriminate;
+exports.discriminate = require_discriminate.discriminate;
+exports.discriminateEntryKey = require_discriminateEntryKey.discriminateEntryKey;
+exports.discriminateEntryValue = require_discriminateEntryValue.discriminateEntryValue;
+exports.entries = require_entries.entries;
+exports.entry = require_entry.entry;
+exports.fromEntries = require_fromEntries.fromEntries;
+exports.getDeepProperty = require_getDeepProperty.getDeepProperty;
+exports.getProperty = require_getProperty.getProperty;
+exports.hasKeys = require_hasKeys.hasKeys;
+exports.isSimple = require_isSimple.isSimple;
+exports.keys = require_keys.keys;
+Object.defineProperty(exports, "object_exports", {
+	enumerable: true,
+	get: function() {
+		return object_exports;
+	}
+});
+exports.omit = require_omit.omit;
+exports.override = require_override.override;
+exports.pick = require_pick.pick;
+exports.to = require_to.to;
+exports.transformProperties = require_transformProperties.transformProperties;
+exports.transformProperty = require_transformProperty.transformProperty;
+exports.values = require_values.values;

package/dist/object/index.d.ts

@@ -0,0 +1,22 @@
+export * from './assign';
+export * from './countKeys';
+export * from './deepDiscriminate';
+export * from './discriminate';
+export * from './discriminateEntryKey';
+export * from './discriminateEntryValue';
+export * from './entries';
+export * from './entry';
+export * from './fromEntries';
+export * from './getDeepProperty';
+export * from './getProperty';
+export * from './hasKeys';
+export * from './isSimple';
+export * from './keys';
+export * from './omit';
+export * from './override';
+export * from './pick';
+export * from './to';
+export * from './transformProperties';
+export * from './transformProperty';
+export type * from './types';
+export * from './values';

package/dist/object/index.mjs

@@ -0,0 +1,48 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
+import { assign } from "./assign.mjs";
+import { countKeys } from "./countKeys.mjs";
+import { getDeepProperty } from "./getDeepProperty.mjs";
+import { deepDiscriminate } from "./deepDiscriminate.mjs";
+import { discriminate } from "./discriminate.mjs";
+import { discriminateEntryKey } from "./discriminateEntryKey.mjs";
+import { discriminateEntryValue } from "./discriminateEntryValue.mjs";
+import { entries } from "./entries.mjs";
+import { entry } from "./entry.mjs";
+import { fromEntries } from "./fromEntries.mjs";
+import { getProperty } from "./getProperty.mjs";
+import { hasKeys } from "./hasKeys.mjs";
+import { isSimple } from "./isSimple.mjs";
+import { keys } from "./keys.mjs";
+import { omit } from "./omit.mjs";
+import { override } from "./override.mjs";
+import { pick } from "./pick.mjs";
+import { to } from "./to.mjs";
+import { transformProperties } from "./transformProperties.mjs";
+import { transformProperty } from "./transformProperty.mjs";
+import { values } from "./values.mjs";
+//#region scripts/object/index.ts
+var object_exports = /* @__PURE__ */ __exportAll({
+	assign: () => assign,
+	countKeys: () => countKeys,
+	deepDiscriminate: () => deepDiscriminate,
+	discriminate: () => discriminate,
+	discriminateEntryKey: () => discriminateEntryKey,
+	discriminateEntryValue: () => discriminateEntryValue,
+	entries: () => entries,
+	entry: () => entry,
+	fromEntries: () => fromEntries,
+	getDeepProperty: () => getDeepProperty,
+	getProperty: () => getProperty,
+	hasKeys: () => hasKeys,
+	isSimple: () => isSimple,
+	keys: () => keys,
+	omit: () => omit,
+	override: () => override,
+	pick: () => pick,
+	to: () => to,
+	transformProperties: () => transformProperties,
+	transformProperty: () => transformProperty,
+	values: () => values
+});
+//#endregion
+export { assign, countKeys, deepDiscriminate, discriminate, discriminateEntryKey, discriminateEntryValue, entries, entry, fromEntries, getDeepProperty, getProperty, hasKeys, isSimple, keys, object_exports, omit, override, pick, to, transformProperties, transformProperty, values };

package/dist/object/isSimple.cjs

@@ -0,0 +1,6 @@
+//#region scripts/object/isSimple.ts
+function isSimple(input) {
+	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor.name === "Object");
+}
+//#endregion
+exports.isSimple = isSimple;

package/dist/object/isSimple.d.ts

@@ -0,0 +1 @@
+export declare function isSimple(input: unknown): input is object;

package/dist/object/isSimple.mjs

@@ -0,0 +1,6 @@
+//#region scripts/object/isSimple.ts
+function isSimple(input) {
+	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor.name === "Object");
+}
+//#endregion
+export { isSimple };

package/dist/object/keys.cjs

@@ -0,0 +1,9 @@
+const require_base = require("../kind/base.cjs");
+//#region scripts/object/keys.ts
+function keys(object) {
+	const result = [];
+	for (const key in object) if (!require_base.isRuntimeKey(key)) result.push(key);
+	return result;
+}
+//#endregion
+exports.keys = keys;

package/dist/object/keys.d.ts

@@ -0,0 +1 @@
+export declare function keys<GenericObject extends object>(object: GenericObject): `${Exclude<keyof GenericObject, symbol>}`[];

package/dist/object/keys.mjs

@@ -0,0 +1,9 @@
+import { isRuntimeKey } from "../kind/base.mjs";
+//#region scripts/object/keys.ts
+function keys(object) {
+	const result = [];
+	for (const key in object) if (!isRuntimeKey(key)) result.push(key);
+	return result;
+}
+//#endregion
+export { keys };

package/dist/object/omit.cjs

@@ -0,0 +1,18 @@
+//#region scripts/object/omit.ts
+function omit(...args) {
+	if (args.length === 1) {
+		const [omitValue] = args;
+		return (input) => omit(input, omitValue);
+	}
+	const [input, omitValue] = args;
+	const formattedOmitValue = Array.isArray(omitValue) ? omitValue.reduce((acc, value) => {
+		acc[String(value)] = true;
+		return acc;
+	}, {}) : Object.fromEntries(Object.entries(omitValue));
+	return Object.entries(input).reduce((acc, [key, value]) => {
+		if (formattedOmitValue[key] !== true) acc[key] = value;
+		return acc;
+	}, {});
+}
+//#endregion
+exports.omit = omit;

package/dist/object/omit.d.ts

@@ -0,0 +1,8 @@
+import { GetPropsWithValue, PartialKeys } from './types';
+import type * as DCommon from '../common';
+type ComputeResultWithOmitIsObject<GenericInput extends object, GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>>> = DCommon.SimplifyTopLevel<Omit<GenericInput, GetPropsWithValue<GenericOmitValue, true>> extends infer InferredValue extends object ? PartialKeys<InferredValue, Extract<GetPropsWithValue<GenericOmitValue, boolean> | GetPropsWithValue<GenericOmitValue, boolean | undefined> | GetPropsWithValue<GenericOmitValue, true | undefined>, keyof InferredValue>> : never>;
+type OmitValue<GenericInput extends object> = Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[];
+type OmitOutput<GenericInput extends object, GenericOmitValue extends OmitValue<GenericInput>> = GenericOmitValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithOmitIsObject<GenericInput, GenericOmitValue> : DCommon.SimplifyTopLevel<Omit<GenericInput, Extract<GenericOmitValue, readonly DCommon.ObjectKey[]>[number]>>;
+export declare function omit<GenericInput extends object, const GenericOmitValue extends OmitValue<GenericInput>>(omitValue: GenericOmitValue): (input: GenericInput) => OmitOutput<GenericInput, GenericOmitValue>;
+export declare function omit<GenericInput extends object, const GenericOmitValue extends OmitValue<GenericInput>>(input: GenericInput, omitValue: GenericOmitValue): OmitOutput<GenericInput, GenericOmitValue>;
+export {};

package/dist/object/omit.mjs

@@ -0,0 +1,18 @@
+//#region scripts/object/omit.ts
+function omit(...args) {
+	if (args.length === 1) {
+		const [omitValue] = args;
+		return (input) => omit(input, omitValue);
+	}
+	const [input, omitValue] = args;
+	const formattedOmitValue = Array.isArray(omitValue) ? omitValue.reduce((acc, value) => {
+		acc[String(value)] = true;
+		return acc;
+	}, {}) : Object.fromEntries(Object.entries(omitValue));
+	return Object.entries(input).reduce((acc, [key, value]) => {
+		if (formattedOmitValue[key] !== true) acc[key] = value;
+		return acc;
+	}, {});
+}
+//#endregion
+export { omit };

package/dist/object/override.cjs

@@ -0,0 +1,14 @@
+//#region scripts/object/override.ts
+function override(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (object) => override(object, value);
+	}
+	const [object, value] = args;
+	return Object.entries(value).reduce((acc, [key, value]) => {
+		if (value !== void 0) acc[key] = value;
+		return acc;
+	}, { ...object });
+}
+//#endregion
+exports.override = override;

package/dist/object/override.d.ts

@@ -0,0 +1,2 @@
+export declare function override<GenericObject extends object>(value: Partial<NoInfer<GenericObject>>): (object: GenericObject) => GenericObject;
+export declare function override<GenericObject extends object>(object: GenericObject, value: Partial<NoInfer<GenericObject>>): GenericObject;

package/dist/object/override.mjs

@@ -0,0 +1,14 @@
+//#region scripts/object/override.ts
+function override(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (object) => override(object, value);
+	}
+	const [object, value] = args;
+	return Object.entries(value).reduce((acc, [key, value]) => {
+		if (value !== void 0) acc[key] = value;
+		return acc;
+	}, { ...object });
+}
+//#endregion
+export { override };

package/dist/object/pick.cjs

@@ -0,0 +1,18 @@
+//#region scripts/object/pick.ts
+function pick(...args) {
+	if (args.length === 1) {
+		const [pickValue] = args;
+		return (input) => pick(input, pickValue);
+	}
+	const [input, pickValue] = args;
+	const formattedPickValue = Array.isArray(pickValue) ? pickValue.reduce((acc, value) => {
+		acc[String(value)] = true;
+		return acc;
+	}, {}) : Object.fromEntries(Object.entries(pickValue));
+	return Object.entries(input).reduce((acc, [key, value]) => {
+		if (formattedPickValue[key] === true) acc[key] = value;
+		return acc;
+	}, {});
+}
+//#endregion
+exports.pick = pick;

package/dist/object/pick.d.ts

@@ -0,0 +1,8 @@
+import { GetPropsWithValue } from './types';
+import type * as DCommon from '../common';
+type ComputeResultWithPickIsObject<GenericInput extends object, GenericPickValue extends Partial<Record<keyof GenericInput, boolean>>> = DCommon.SimplifyTopLevel<Pick<GenericInput, Extract<GetPropsWithValue<GenericPickValue, true>, keyof GenericInput>> & Partial<Pick<GenericInput, Extract<GetPropsWithValue<GenericPickValue, boolean> | GetPropsWithValue<GenericPickValue, boolean | undefined> | GetPropsWithValue<GenericPickValue, true | undefined>, keyof GenericInput>>>>;
+type PickValue<GenericInput extends object> = Partial<Record<keyof GenericInput, boolean>> | readonly (keyof GenericInput)[];
+type PickOutput<GenericInput extends object, GenericPickValue extends PickValue<GenericInput>> = GenericPickValue extends Partial<Record<keyof GenericInput, boolean>> ? ComputeResultWithPickIsObject<GenericInput, GenericPickValue> : DCommon.SimplifyTopLevel<Pick<GenericInput, Extract<GenericPickValue, readonly DCommon.ObjectKey[]>[number]>>;
+export declare function pick<GenericInput extends object, const GenericPickValue extends PickValue<GenericInput>>(pickValue: GenericPickValue): (input: GenericInput) => PickOutput<GenericInput, GenericPickValue>;
+export declare function pick<GenericInput extends object, const GenericPickValue extends PickValue<GenericInput>>(input: GenericInput, pickValue: GenericPickValue): PickOutput<GenericInput, GenericPickValue>;
+export {};

package/dist/object/pick.mjs

@@ -0,0 +1,18 @@
+//#region scripts/object/pick.ts
+function pick(...args) {
+	if (args.length === 1) {
+		const [pickValue] = args;
+		return (input) => pick(input, pickValue);
+	}
+	const [input, pickValue] = args;
+	const formattedPickValue = Array.isArray(pickValue) ? pickValue.reduce((acc, value) => {
+		acc[String(value)] = true;
+		return acc;
+	}, {}) : Object.fromEntries(Object.entries(pickValue));
+	return Object.entries(input).reduce((acc, [key, value]) => {
+		if (formattedPickValue[key] === true) acc[key] = value;
+		return acc;
+	}, {});
+}
+//#endregion
+export { pick };

package/dist/object/to.cjs

@@ -0,0 +1,14 @@
+//#region scripts/object/to.ts
+function to(...args) {
+	if (args.length === 1) {
+		const [shape] = args;
+		return (input) => to(input, shape);
+	}
+	const [input, shapeObject] = args;
+	return Object.entries(shapeObject).reduce((acc, [key, theFunction]) => {
+		acc[key] = theFunction?.(input);
+		return acc;
+	}, {});
+}
+//#endregion
+exports.to = to;