@visulima/object 1.0.7 → 1.0.9

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## @visulima/object [1.0.9](https://github.com/visulima/visulima/compare/@visulima/object@1.0.8...@visulima/object@1.0.9) (2025-01-25)
+
+### Bug Fixes
+
+* fixed wrong node version range in package.json ([4ae2929](https://github.com/visulima/visulima/commit/4ae292984681c71a770e4d4560432f7b7c5a141a))
+
+### Miscellaneous Chores
+
+* fixed typescript url ([fe65a8c](https://github.com/visulima/visulima/commit/fe65a8c0296ece7ee26474c70d065b06d4d0da89))
+* updated all dev dependencies ([37fb298](https://github.com/visulima/visulima/commit/37fb298b2af7c63be64252024e54bb3af6ddabec))
+* updated all dev dependencies and all dependencies in the app folder ([87f4ccb](https://github.com/visulima/visulima/commit/87f4ccbf9f7900ec5b56f3c1477bc4a0ef571bcf))
+
+## @visulima/object [1.0.8](https://github.com/visulima/visulima/compare/@visulima/object@1.0.7...@visulima/object@1.0.8) (2025-01-12)
+
+### Bug Fixes
+
+* updated @visulima/packem, and all other dev dependencies ([7797a1c](https://github.com/visulima/visulima/commit/7797a1c3e6f1fc532895247bd88285a8a9883c40))
+
+### Miscellaneous Chores
+
+* updated dev dependencies ([9de2eab](https://github.com/visulima/visulima/commit/9de2eab91e95c8b9289d12f863a5167218770650))
+
 ## @visulima/object [1.0.7](https://github.com/visulima/visulima/compare/@visulima/object@1.0.6...@visulima/object@1.0.7) (2024-12-12)
 
 ### Bug Fixes

package/README.md

@@ -129,7 +129,7 @@ If you would like to help take a look at the [list of issues](https://github.com
 The visulima object is open-sourced software licensed under the [MIT][license-url]
 
 [typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
-[typescript-url]: "typescript"
+[typescript-url]: https://www.typescriptlang.org/ "TypeScript" "typescript"
 [license-image]: https://img.shields.io/npm/l/@visulima/object?color=blueviolet&style=for-the-badge
 [license-url]: LICENSE.md "license"
 [npm-image]: https://img.shields.io/npm/v/@visulima/object/latest.svg?style=for-the-badge&logo=npm

package/dist/index.cjs

@@ -1 +1,187 @@
-"use strict";var L=Object.defineProperty;var a=(c,p)=>L(c,"name",{value:p,configurable:!0});Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const M=require("./packem_shared/omit-BQOPjoaX.cjs"),N=require("./packem_shared/pick-fC8KqJig.cjs"),b=require("./packem_shared/getProperty-Crh_HruK.cjs"),R=require("./packem_shared/isPlainObject-Ct8-08mJ.cjs");var s={},y={},D;function T(){if(D)return y;D=1;var c=Object.defineProperty,p=a((o,m)=>c(o,"name",{value:m,configurable:!0}),"t");Object.defineProperty(y,"__esModule",{value:!0}),y.isDocumentToRecurOn=y.flatten=y.unique=void 0;function u(o){return[...new Set(o)]}a(u,"unique"),p(u,"unique"),y.unique=u;function l(o){return[].concat(...o)}a(l,"flatten"),p(l,"flatten"),y.flatten=l;function g(o){return typeof o=="object"&&o!==null&&!Array.isArray(o)&&Object.keys(o).length}return a(g,"isDocumentToRecurOn"),p(g,"isDocumentToRecurOn"),y.isDocumentToRecurOn=g,y}a(T,"requireUtils");var K={},q;function E(){return q||(q=1,Object.defineProperty(K,"__esModule",{value:!0})),K}a(E,"requireTypes");var S;function x(){return S||(S=1,function(c){var p=Object.defineProperty,u=a((r,e)=>p(r,"name",{value:e,configurable:!0}),"i"),l=s&&s.__createBinding||(Object.create?function(r,e,t,i){i===void 0&&(i=t);var n=Object.getOwnPropertyDescriptor(e,t);(!n||("get"in n?!e.__esModule:n.writable||n.configurable))&&(n={enumerable:!0,get:u(function(){return e[t]},"get")}),Object.defineProperty(r,i,n)}:function(r,e,t,i){i===void 0&&(i=t),r[i]=e[t]}),g=s&&s.__setModuleDefault||(Object.create?function(r,e){Object.defineProperty(r,"default",{enumerable:!0,value:e})}:function(r,e){r.default=e}),o=s&&s.__importStar||function(r){if(r&&r.__esModule)return r;var e={};if(r!=null)for(var t in r)t!=="default"&&Object.prototype.hasOwnProperty.call(r,t)&&l(e,r,t);return g(e,r),e},m=s&&s.__exportStar||function(r,e){for(var t in r)t!=="default"&&!Object.prototype.hasOwnProperty.call(e,t)&&l(e,r,t)};Object.defineProperty(c,"__esModule",{value:!0}),c.deepKeysFromList=c.deepKeys=void 0;const d=o(T());m(E(),c);function O(r,e){const t=A(e);return typeof r=="object"&&r!==null?_("",r,t):[]}a(O,"deepKeys"),u(O,"deepKeys"),c.deepKeys=O;function v(r,e){const t=A(e);return r.map(i=>typeof i=="object"&&i!==null?O(i,t):[])}a(v,"deepKeysFromList"),u(v,"deepKeysFromList"),c.deepKeysFromList=v;function _(r,e,t){const i=Object.keys(e).map(n=>{const f=P(r,j(n,t));return t.expandNestedObjects&&d.isDocumentToRecurOn(e[n])||t.arrayIndexesAsKeys&&Array.isArray(e[n])&&e[n].length?_(f,e[n],t):t.expandArrayObjects&&Array.isArray(e[n])?h(e[n],f,t):t.ignoreEmptyArrays&&Array.isArray(e[n])&&!e[n].length?[]:f});return d.flatten(i)}a(_,"generateDeepKeysList"),u(_,"generateDeepKeysList");function h(r,e,t){let i=v(r,t);return r.length?r.length&&d.flatten(i).length===0?[e]:(i=i.map(n=>Array.isArray(n)&&n.length===0?[e]:n.map(f=>P(e,j(f,t)))),d.unique(d.flatten(i))):t.ignoreEmptyArraysWhenExpanding?[]:[e]}a(h,"processArrayKeys"),u(h,"processArrayKeys");function j(r,e){return e.escapeNestedDots?r.replace(/\./g,"\\."):r}a(j,"escapeNestedDotsIfSpecified"),u(j,"escapeNestedDotsIfSpecified");function P(r,e){return r?r+"."+e:e}a(P,"buildKeyName"),u(P,"buildKeyName");function A(r){return{arrayIndexesAsKeys:!1,expandNestedObjects:!0,expandArrayObjects:!1,ignoreEmptyArraysWhenExpanding:!1,escapeNestedDots:!1,ignoreEmptyArrays:!1,...r??{}}}a(A,"mergeOptions"),u(A,"mergeOptions")}(s)),s}a(x,"requireDeeks");var k=x();exports.omit=M;exports.pick=N;exports.deleteProperty=b.deleteProperty;exports.escapePath=b.escapePath;exports.getProperty=b.getProperty;exports.hasProperty=b.hasProperty;exports.setProperty=b.setProperty;exports.isPlainObject=R;exports.deepKeys=k.deepKeys;exports.deepKeysFromList=k.deepKeysFromList;
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const omit = require('./packem_shared/omit-DSwyUtN2.cjs');
+const pick = require('./packem_shared/pick-BX11mP2m.cjs');
+const getProperty = require('./packem_shared/getProperty-BuSUBWTY.cjs');
+const isPlainObject = require('./packem_shared/isPlainObject-D2hOGcuW.cjs');
+
+var deeks = {};
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	var __defProp = Object.defineProperty;
+	var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+	Object.defineProperty(utils, "__esModule", { value: true });
+	utils.isDocumentToRecurOn = utils.flatten = utils.unique = undefined;
+	function unique(array) {
+	  return [...new Set(array)];
+	}
+	__name(unique, "unique");
+	utils.unique = unique;
+	function flatten(array) {
+	  return [].concat(...array);
+	}
+	__name(flatten, "flatten");
+	utils.flatten = flatten;
+	function isDocumentToRecurOn(val) {
+	  return typeof val === "object" && val !== null && !Array.isArray(val) && Object.keys(val).length;
+	}
+	__name(isDocumentToRecurOn, "isDocumentToRecurOn");
+	utils.isDocumentToRecurOn = isDocumentToRecurOn;
+	return utils;
+}
+
+var types = {};
+
+var hasRequiredTypes;
+
+function requireTypes () {
+	if (hasRequiredTypes) return types;
+	hasRequiredTypes = 1;
+	Object.defineProperty(types, "__esModule", { value: true });
+	return types;
+}
+
+var hasRequiredDeeks;
+
+function requireDeeks () {
+	if (hasRequiredDeeks) return deeks;
+	hasRequiredDeeks = 1;
+	(function (exports) {
+		var __defProp = Object.defineProperty;
+		var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+		var __createBinding = deeks.__createBinding || (Object.create ? function(o, m, k, k2) {
+		  if (k2 === undefined) k2 = k;
+		  var desc = Object.getOwnPropertyDescriptor(m, k);
+		  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		    desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
+		      return m[k];
+		    }, "get") };
+		  }
+		  Object.defineProperty(o, k2, desc);
+		} : function(o, m, k, k2) {
+		  if (k2 === undefined) k2 = k;
+		  o[k2] = m[k];
+		});
+		var __setModuleDefault = deeks.__setModuleDefault || (Object.create ? function(o, v) {
+		  Object.defineProperty(o, "default", { enumerable: true, value: v });
+		} : function(o, v) {
+		  o["default"] = v;
+		});
+		var __importStar = deeks.__importStar || function(mod) {
+		  if (mod && mod.__esModule) return mod;
+		  var result = {};
+		  if (mod != null) {
+		    for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+		  }
+		  __setModuleDefault(result, mod);
+		  return result;
+		};
+		var __exportStar = deeks.__exportStar || function(m, exports2) {
+		  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.deepKeysFromList = exports.deepKeys = undefined;
+		const utils = __importStar(requireUtils());
+		__exportStar(requireTypes(), exports);
+		function deepKeys(object, options) {
+		  const parsedOptions = mergeOptions(options);
+		  if (typeof object === "object" && object !== null) {
+		    return generateDeepKeysList("", object, parsedOptions);
+		  }
+		  return [];
+		}
+		__name(deepKeys, "deepKeys");
+		exports.deepKeys = deepKeys;
+		function deepKeysFromList(list, options) {
+		  const parsedOptions = mergeOptions(options);
+		  return list.map((document) => {
+		    if (typeof document === "object" && document !== null) {
+		      return deepKeys(document, parsedOptions);
+		    }
+		    return [];
+		  });
+		}
+		__name(deepKeysFromList, "deepKeysFromList");
+		exports.deepKeysFromList = deepKeysFromList;
+		function generateDeepKeysList(heading, data, options) {
+		  const keys = Object.keys(data).map((currentKey) => {
+		    const keyName = buildKeyName(heading, escapeNestedDotsIfSpecified(currentKey, options));
+		    if (options.expandNestedObjects && utils.isDocumentToRecurOn(data[currentKey]) || options.arrayIndexesAsKeys && Array.isArray(data[currentKey]) && data[currentKey].length) {
+		      return generateDeepKeysList(keyName, data[currentKey], options);
+		    } else if (options.expandArrayObjects && Array.isArray(data[currentKey])) {
+		      return processArrayKeys(data[currentKey], keyName, options);
+		    } else if (options.ignoreEmptyArrays && Array.isArray(data[currentKey]) && !data[currentKey].length) {
+		      return [];
+		    }
+		    return keyName;
+		  });
+		  return utils.flatten(keys);
+		}
+		__name(generateDeepKeysList, "generateDeepKeysList");
+		function processArrayKeys(subArray, currentKeyPath, options) {
+		  let subArrayKeys = deepKeysFromList(subArray, options);
+		  if (!subArray.length) {
+		    return options.ignoreEmptyArraysWhenExpanding ? [] : [currentKeyPath];
+		  } else if (subArray.length && utils.flatten(subArrayKeys).length === 0) {
+		    return [currentKeyPath];
+		  } else {
+		    subArrayKeys = subArrayKeys.map((schemaKeys) => {
+		      if (Array.isArray(schemaKeys) && schemaKeys.length === 0) {
+		        return [currentKeyPath];
+		      }
+		      return schemaKeys.map((subKey) => buildKeyName(currentKeyPath, escapeNestedDotsIfSpecified(subKey, options)));
+		    });
+		    return utils.unique(utils.flatten(subArrayKeys));
+		  }
+		}
+		__name(processArrayKeys, "processArrayKeys");
+		function escapeNestedDotsIfSpecified(key, options) {
+		  if (options.escapeNestedDots) {
+		    return key.replace(/\./g, "\\.");
+		  }
+		  return key;
+		}
+		__name(escapeNestedDotsIfSpecified, "escapeNestedDotsIfSpecified");
+		function buildKeyName(upperKeyName, currentKeyName) {
+		  if (upperKeyName) {
+		    return upperKeyName + "." + currentKeyName;
+		  }
+		  return currentKeyName;
+		}
+		__name(buildKeyName, "buildKeyName");
+		function mergeOptions(options) {
+		  return {
+		    arrayIndexesAsKeys: false,
+		    expandNestedObjects: true,
+		    expandArrayObjects: false,
+		    ignoreEmptyArraysWhenExpanding: false,
+		    escapeNestedDots: false,
+		    ignoreEmptyArrays: false,
+		    ...options ?? {}
+		  };
+		}
+		__name(mergeOptions, "mergeOptions"); 
+	} (deeks));
+	return deeks;
+}
+
+var deeksExports = requireDeeks();
+
+exports.omit = omit;
+exports.pick = pick;
+exports.deleteProperty = getProperty.deleteProperty;
+exports.escapePath = getProperty.escapePath;
+exports.getProperty = getProperty.getProperty;
+exports.hasProperty = getProperty.hasProperty;
+exports.setProperty = getProperty.setProperty;
+exports.isPlainObject = isPlainObject;
+exports.deepKeys = deeksExports.deepKeys;
+exports.deepKeysFromList = deeksExports.deepKeysFromList;

package/dist/index.d.cts

@@ -19,6 +19,68 @@ declare global {
 	}
 }
 
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void)
+	// The `& Union` is to allow indexing by the resulting type
+	? Intersection & Union
+	: never;
+
 declare const emptyObjectSymbol: unique symbol;
 
 /**
@@ -76,8 +138,8 @@ type Includes<Value extends readonly any[], Item> =
 @category Utilities
 */
 type IsEqual<A, B> =
-	(<G>() => G extends A ? 1 : 2) extends
-	(<G>() => G extends B ? 1 : 2)
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
 		? true
 		: false;
 
@@ -166,6 +228,72 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 */
 type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
 
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (
+	IsNever<T> extends true ? TypeIfNever : TypeIfNotNever
+);
+
 /**
 Returns the static, fixed-length portion of the given array, excluding variable-length parts.
 
@@ -227,7 +355,7 @@ T extends readonly [...infer U] ?
 /**
 Returns whether the given array `T` is readonly.
 */
-type IsArrayReadonly<T extends UnknownArray> = T extends unknown[] ? false : true;
+type IsArrayReadonly<T extends UnknownArray> = IfNever<T, false, T extends unknown[] ? false : true>;
 
 type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
 
@@ -324,49 +452,6 @@ type ShouldBeTrue = IsNegative<-1>;
 */
 type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;
 
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNever<T> = [T] extends [never] ? true : false;
-
 /**
 Returns a boolean for whether two given types are both true.
 
@@ -537,9 +622,11 @@ If `<Fill>` is not provided, it will default to `unknown`.
 
 @link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
 */
-type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = T['length'] extends L
-	? T
-	: BuildTuple<L, Fill, [...T, Fill]>;
+type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = number extends L
+	? Fill[]
+	: L extends T['length']
+		? T
+		: BuildTuple<L, Fill, [...T, Fill]>;
 
 /**
 Returns the maximum value from a tuple of integers.
@@ -1314,68 +1401,6 @@ type InternalPaths<T, Options extends Required<PathsOptions>> =
 			: never
 		: never;
 
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
-```
-
-A more applicable example which could make its way into your library code follows.
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-class CommandOne {
-	commands: {
-		a1: () => undefined,
-		b1: () => undefined,
-	}
-}
-
-class CommandTwo {
-	commands: {
-		a2: (argA: string) => undefined,
-		b2: (argB: string) => undefined,
-	}
-}
-
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
-
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
-```
-
-@category Type
-*/
-type UnionToIntersection<Union> = (
-	// `extends unknown` is always going to be the case and is used to convert the
-	// `Union` into a [distributive conditional
-	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-	Union extends unknown
-		// The union type is used as the only argument to a function since the union
-		// of function arguments is an intersection.
-		? (distributedUnion: Union) => void
-		// This won't happen.
-		: never
-		// Infer the `Intersection` type since TypeScript represents the positional
-		// arguments of unions of functions as an intersection of the union.
-) extends ((mergedIntersection: infer Intersection) => void)
-	// The `& Union` is to allow indexing by the resulting type
-	? Intersection & Union
-	: never;
-
 /**
 Pick properties from a deeply-nested object.
 
@@ -2017,11 +2042,17 @@ array = split(items, ',');
 type Split<
 	S extends string,
 	Delimiter extends string,
+> = SplitHelper<S, Delimiter>;
+
+type SplitHelper<
+	S extends string,
+	Delimiter extends string,
+	Accumulator extends string[] = [],
 > = S extends `${infer Head}${Delimiter}${infer Tail}`
-	? [Head, ...Split<Tail, Delimiter>]
-	: S extends Delimiter
-		? []
-		: [S];
+	? SplitHelper<Tail, Delimiter, [...Accumulator, Head]>
+	: Delimiter extends ''
+		? Accumulator
+		: [...Accumulator, S];
 
 type GetOptions = {
 	/**
@@ -2224,7 +2255,7 @@ type Get<
 	BaseType,
 	Path extends
 	| readonly string[]
-	| LiteralStringUnion<ToString<Paths<BaseType, {bracketNotation: false}> | Paths<BaseType, {bracketNotation: true}>>>,
+	| LiteralStringUnion<ToString<Paths<BaseType, {bracketNotation: false; maxRecursionDepth: 2}> | Paths<BaseType, {bracketNotation: true; maxRecursionDepth: 2}>>>,
 	Options extends GetOptions = {}> =
 		GetWithPath<BaseType, Path extends string ? ToPath<Path> : Path, Options>;