@quantiya/codevibe-claude-plugin 2.0.27 → 2.0.28

package/node_modules/qs/test/stringify.js

@@ -136,144 +136,6 @@ test('stringify()', function (t) {
         st.end();
     });
 
-    t.test('encodes dot in key of object with a primitive value when encodeDotInKeys and allowDots is provided', function (st) {
-        st.equal(
-            qs.stringify(
-                { 'name.obj': 'John' },
-                { allowDots: true, encodeDotInKeys: true }
-            ),
-            'name%252Eobj=John',
-            'with allowDots true and encodeDotInKeys true'
-        );
-        st.equal(
-            qs.stringify(
-                { 'name.obj': 'John' },
-                { allowDots: false, encodeDotInKeys: true }
-            ),
-            'name%252Eobj=John',
-            'with allowDots false and encodeDotInKeys true'
-        );
-        st.equal(
-            qs.stringify(
-                { 'name.obj': 'John' },
-                { encodeDotInKeys: true, allowDots: true, encodeValuesOnly: true }
-            ),
-            'name%2Eobj=John',
-            'with encodeValuesOnly true'
-        );
-
-        // With `encodeValuesOnly` the key encoder is skipped, so the dot is encoded once
-        // (`%2E`) rather than twice. That single `%2E` decodes back to a structural dot, so
-        // unlike the default output below this does not round-trip to the original dotted key
-        // (a pre-existing `encodeValuesOnly` + `encodeDotInKeys` limitation, not new here).
-        st.deepEqual(
-            qs.parse(
-                qs.stringify(
-                    { 'name.obj': 'John' },
-                    { encodeDotInKeys: true, allowDots: true, encodeValuesOnly: true }
-                ),
-                { allowDots: true, decodeDotInKeys: true }
-            ),
-            { name: { obj: 'John' } },
-            'with encodeValuesOnly the single-encoded dot decodes structurally (does not round-trip)'
-        );
-
-        st.deepEqual(
-            qs.parse(
-                qs.stringify({ 'name.obj': 'John' }, { allowDots: true, encodeDotInKeys: true }),
-                { allowDots: true, decodeDotInKeys: true }
-            ),
-            { 'name.obj': 'John' },
-            'round-trips a dotted key with a primitive value'
-        );
-
-        st.equal(
-            qs.stringify({ 'a.b': null }, { allowDots: true, encodeDotInKeys: true, strictNullHandling: true }),
-            'a%252Eb',
-            'encodes a dotted key with a null value'
-        );
-        st.equal(
-            qs.stringify({ 'a.b': '1', 'c.d': '2' }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb=1&c%252Ed=2',
-            'encodes dots in every top-level key, not just the first'
-        );
-        st.equal(
-            qs.stringify({ 'a.b.c': 'x' }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb%252Ec=x',
-            'encodes every dot in a key'
-        );
-        var primitiveKey = qs.stringify({ 'a.b': 'c' }, { allowDots: true, encodeDotInKeys: true }).split('=')[0];
-        st.equal(
-            qs.stringify({ 'a.b': { x: 'c' } }, { allowDots: true, encodeDotInKeys: true }).indexOf(primitiveKey + '.'),
-            0,
-            'a top-level dotted key encodes identically for primitive and object values'
-        );
-
-        st.end();
-    });
-
-    // Characterization of the CURRENT (buggy) behavior: with `allowDots` + `encodeDotInKeys`,
-    // `stringify` percent-encodes the structural `.` separators that `allowDots` inserts between
-    // nested keys, not just the literal dots inside a key, which breaks the stringify -> parse
-    // round-trip. These assertions pin that behavior so it cannot change silently: the fix in
-    // https://github.com/ljharb/qs/pull/564 changes every output below, so landing that fix MUST
-    // update this test (that is the point — it forces the behavior change to be explicit).
-    t.test('[characterization] encodeDotInKeys currently over-encodes structural separator dots (pre-#564)', function (st) {
-        st.equal(
-            qs.stringify({ a: { b: { c: 'd' } } }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb.c=d',
-            'over-encodes the a->b separator (#564: should become a.b.c=d)'
-        );
-        st.equal(
-            qs.stringify({ a: { b: { c: { d: 'e' } } } }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb%252Ec.d=e',
-            'clobbers every separator but the last (#564: should become a.b.c.d=e)'
-        );
-        st.equal(
-            qs.stringify({ 'a.b': { c: { d: 'e' } } }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb%252Ec.d=e',
-            'top-level dotted key: deeper separators also get encoded (#564: should become a%252Eb.c.d=e)'
-        );
-        st.equal(
-            qs.stringify({ a: { 'b.c': { d: 'e' } } }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb%252Ec.d=e',
-            'nested dotted key + object value: the separator around it is encoded (#564: should become a.b%252Ec.d=e)'
-        );
-        st.equal(
-            qs.stringify({ a: { b: { 'c.d': { e: 'f' } } } }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb%252Ec%252Ed.e=f',
-            'deeply nested dotted key: all separators encoded (#564: should become a.b.c%252Ed.e=f)'
-        );
-
-        st.equal(
-            qs.stringify({ a: { b: [1, 2] } }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb%5B0%5D=1&a%252Eb%5B1%5D=2',
-            'array value under nested keys: separator encoded (#564: should become a.b%5B0%5D=1&a.b%5B1%5D=2)'
-        );
-        st.equal(
-            qs.stringify({ a: { 'b.c': [1, 2] } }, { allowDots: true, encodeDotInKeys: true }),
-            'a%252Eb%252Ec%5B0%5D=1&a%252Eb%252Ec%5B1%5D=2',
-            'array value under nested dotted key (#564: should become a.b%252Ec%5B0%5D=1&a.b%252Ec%5B1%5D=2)'
-        );
-
-        st.equal(
-            qs.stringify({ a: { 'b.c': { d: 'e' } } }, { allowDots: false, encodeDotInKeys: true }),
-            'a%5Bb%252Ec%5D%5Bd%5D=e',
-            'allowDots:false object value encodes the nested-key dot, unlike the primitive-value case (#564: should become a%5Bb.c%5D%5Bd%5D=e)'
-        );
-
-        st.deepEqual(
-            qs.parse(
-                qs.stringify({ a: { b: { c: 'd' } } }, { allowDots: true, encodeDotInKeys: true }),
-                { allowDots: true, decodeDotInKeys: true }
-            ),
-            { 'a.b': { c: 'd' } },
-            'the over-encoding breaks the round-trip: {a:{b:{c}}} comes back as {"a.b":{c}} (#564 restores it)'
-        );
-
-        st.end();
-    });
-
     t.test('should encode dot in key of object, and automatically set allowDots to `true` when encodeDotInKeys is true and allowDots in undefined', function (st) {
         st.equal(
             qs.stringify(
@@ -466,39 +328,6 @@ test('stringify()', function (t) {
         st.end();
     });
 
-    t.test('allowEmptyArrays only short-circuits arrays with no own keys', function (st) {
-        st.equal(
-            qs.stringify({ a: [] }, { allowEmptyArrays: true }),
-            'a[]',
-            'a genuinely empty array is still emitted as `[]`'
-        );
-
-        var withKey = [];
-        withKey.extra = 'x';
-        st.equal(
-            qs.stringify({ a: withKey }, { allowEmptyArrays: true }),
-            'a%5Bextra%5D=x',
-            'an own key on an empty array is serialized rather than dropped'
-        );
-        st.equal(
-            qs.stringify({ a: withKey }, { allowEmptyArrays: true }),
-            qs.stringify({ a: withKey }),
-            'the allowEmptyArrays fast path matches the default path when the array has own keys'
-        );
-
-        var container = {};
-        var cyclic = [];
-        cyclic.back = container;
-        container.a = cyclic;
-        st['throws'](
-            function () { qs.stringify(container, { allowEmptyArrays: true }); },
-            RangeError,
-            'a cycle through an empty array with an own key is still detected'
-        );
-
-        st.end();
-    });
-
     t.test('stringifies an array value with one item vs multiple items', function (st) {
         st.test('non-array item', function (s2t) {
             s2t.equal(qs.stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'indices' }), 'a=c');
@@ -932,33 +761,6 @@ test('stringify()', function (t) {
         st.end();
     });
 
-    t.test('does not throw on a non-callable `constructor.isBuffer` key', function (st) {
-        var input = { a: { constructor: { isBuffer: 'x' } } };
-        st.doesNotThrow(function () { qs.stringify(input); });
-        st.equal(qs.stringify(input), 'a%5Bconstructor%5D%5BisBuffer%5D=x');
-        st.equal(qs.stringify({ a: { constructor: { isBuffer: { b: 'c' } } } }), 'a%5Bconstructor%5D%5BisBuffer%5D%5Bb%5D=c');
-        st.equal(qs.stringify({ a: { constructor: { isBuffer: ['b'] } } }), 'a%5Bconstructor%5D%5BisBuffer%5D%5B0%5D=b');
-        st.equal(qs.stringify({ a: { constructor: { isBuffer: true } } }), 'a%5Bconstructor%5D%5BisBuffer%5D=true');
-        st.end();
-    });
-
-    t.test('round-trips a parsed `constructor[isBuffer]` key', function (st) {
-        var str = 'x%5Bconstructor%5D%5BisBuffer%5D=y';
-
-        var plain = qs.parse(str, { plainObjects: true });
-        st.deepEqual(plain, { __proto__: null, x: { __proto__: null, constructor: { __proto__: null, isBuffer: 'y' } } }, 'plainObjects keeps the key');
-        st.doesNotThrow(function () { qs.stringify(plain); });
-        st.equal(qs.stringify(plain), str, 'plainObjects round-trips');
-
-        var proto = qs.parse(str, { allowPrototypes: true });
-        st.deepEqual(proto, { x: { constructor: { isBuffer: 'y' } } }, 'allowPrototypes keeps the key');
-        st.doesNotThrow(function () { qs.stringify(proto); });
-        st.equal(qs.stringify(proto), str, 'allowPrototypes round-trips');
-
-        st.equal(qs.stringify(qs.parse(str)), '', 'default options drop the key');
-        st.end();
-    });
-
     t.test('stringifies an object using an alternative delimiter', function (st) {
         st.equal(qs.stringify({ a: 'b', c: 'd' }, { delimiter: ';' }), 'a=b;c=d');
         st.end();
@@ -1117,66 +919,6 @@ test('stringify()', function (t) {
         st.end();
     });
 
-    t.test('serializes Date values unless filter transforms them', function (st) {
-        var obj = {
-            a: new Date(Date.UTC(2023, 2, 7, 9, 2, 41, 260)),
-            b: [new Date(Date.UTC(2023, 2, 7, 9, 2, 41, 260))]
-        };
-        var iso = '2023-03-07T09%3A02%3A41.260Z';
-        st.equal(
-            qs.stringify(obj, { filter: function (prefix, value) { return value; } }),
-            'a=' + iso + '&b%5B0%5D=' + iso,
-            'Dates returned unchanged by a filter are serialized'
-        );
-        st.equal(
-            qs.stringify({ a: new Date(0) }, { filter: function (prefix, value) { return value instanceof Date ? 'kept' : value; } }),
-            'a=kept',
-            'a filter that transforms a Date wins over default serialization'
-        );
-        st.end();
-    });
-
-    t.test('applies default Date handling to whatever a filter function returns', function (st) {
-        var date = new Date(Date.UTC(2023, 2, 7, 9, 2, 41, 260));
-        var iso = '2023-03-07T09%3A02%3A41.260Z';
-        var identity = function (prefix, value) { return value; };
-
-        st.equal(
-            qs.stringify({ a: { b: date } }, { filter: identity }),
-            'a%5Bb%5D=' + iso,
-            'a nested Date is serialized through a filter'
-        );
-        st.equal(
-            qs.stringify(
-                { a: date },
-                { filter: identity, serializeDate: function (d) { return String(d.getTime()); } }
-            ),
-            'a=1678179761260',
-            '`serializeDate` is honored after a filter'
-        );
-        st.equal(
-            qs.stringify({ a: [date, 'x'] }, { filter: identity, arrayFormat: 'comma' }),
-            'a=' + iso + '%2Cx',
-            'Dates inside a comma array are serialized through a filter, not stringified as locale text'
-        );
-        st.equal(
-            qs.stringify({ a: 'x' }, { filter: function (prefix, value) { return prefix === 'a' ? date : value; } }),
-            'a=' + iso,
-            'a Date produced by the filter is serialized'
-        );
-        st.equal(
-            qs.stringify({ a: date, b: 1 }, { filter: ['a'] }),
-            'a=' + iso,
-            'an array filter still serializes Dates'
-        );
-        st['throws'](
-            function () { qs.stringify({ a: new Date(NaN) }, { filter: identity }); },
-            RangeError,
-            'an invalid Date through a filter throws like the no-filter path'
-        );
-        st.end();
-    });
-
     t.test('can disable uri encoding', function (st) {
         st.equal(qs.stringify({ a: 'b' }, { encode: false }), 'a=b');
         st.equal(qs.stringify({ a: { b: 'c' } }, { encode: false }), 'a[b]=c');
@@ -1703,63 +1445,4 @@ test('stringifies empty keys', function (t) {
 
         st.end();
     });
-
-    t.test('limits nesting depth with the `depth` option', function (st) {
-        st.equal(
-            qs.stringify({ a: { b: { c: 'd' } } }),
-            'a%5Bb%5D%5Bc%5D=d',
-            'the default depth is unlimited and does not alter output'
-        );
-        st.equal(
-            qs.stringify({ a: { b: { c: 'd' } } }, { depth: 2 }),
-            'a%5Bb%5D%5Bc%5D=d',
-            'does not throw when nesting is within the depth limit'
-        );
-        st.equal(
-            qs.stringify({ a: { b: 'c' } }, { depth: Infinity }),
-            'a%5Bb%5D=c',
-            'an explicit Infinity depth is unlimited'
-        );
-        st.equal(
-            qs.stringify({ a: { b: { c: { d: 'e' } } } }, { depth: null }),
-            qs.stringify({ a: { b: { c: { d: 'e' } } } }),
-            'a non-number depth is ignored and treated as unlimited'
-        );
-        st.equal(
-            qs.stringify({ a: 'b' }, { depth: 0 }),
-            'a=b',
-            'a flat object serializes with a depth of 0'
-        );
-
-        var deep = {};
-        var cursor = deep;
-        for (var i = 0; i < 250; i++) {
-            cursor.a = {};
-            cursor = cursor.a;
-        }
-        cursor.b = 'c';
-        st.equal(typeof qs.stringify(deep), 'string', 'the default depth serializes deeply nested objects without throwing');
-
-        st['throws'](
-            function () { qs.stringify({ a: { b: { c: { d: 'e' } } } }, { depth: 2 }); },
-            RangeError,
-            'throws a RangeError when nesting exceeds the depth limit'
-        );
-        st['throws'](
-            function () { qs.stringify({ a: { b: 'c' } }, { depth: 0 }); },
-            RangeError,
-            'a depth of 0 throws for any nested object'
-        );
-
-        var caught;
-        try {
-            qs.stringify({ a: { b: { c: { d: 'e' } } } }, { depth: 2 });
-        } catch (e) {
-            caught = e;
-        }
-        st.ok(caught instanceof RangeError, 'the thrown value is a RangeError');
-        st.equal(caught.message, 'Input depth exceeded depth option of 2', 'the RangeError names the exceeded depth');
-
-        st.end();
-    });
 });

package/node_modules/qs/test/utils.js

@@ -604,18 +604,6 @@ test('isBuffer()', function (t) {
     var fakeBuffer = { constructor: Buffer };
     t.equal(utils.isBuffer(fakeBuffer), false, 'fake buffer is not a buffer');
 
-    forEach(['x', 1, true, {}, [], { isBuffer: true }], function (notCallable) {
-        var obj = { constructor: { isBuffer: notCallable } };
-        t.doesNotThrow(function () { utils.isBuffer(obj); }, 'non-callable `constructor.isBuffer` (' + inspect(notCallable) + ') does not throw');
-        t.equal(utils.isBuffer(obj), false, 'non-callable `constructor.isBuffer` (' + inspect(notCallable) + ') is not a buffer');
-    });
-
-    var nullObject = { __proto__: null, constructor: { __proto__: null, isBuffer: 'y' } };
-    t.equal(utils.isBuffer(nullObject), false, 'null object with non-callable `constructor.isBuffer` is not a buffer');
-
-    var duckBuffer = { constructor: { isBuffer: function () { return true; } } };
-    t.equal(utils.isBuffer(duckBuffer), true, 'callable `constructor.isBuffer` is still honored');
-
     var saferBuffer = SaferBuffer.from('abc');
     t.equal(utils.isBuffer(saferBuffer), true, 'SaferBuffer instance is a buffer');
 

package/node_modules/type-fest/index.d.ts

@@ -103,7 +103,6 @@ export type {KeyAsString} from './source/key-as-string.d.ts';
 export type {Exact} from './source/exact.d.ts';
 export type {ReadonlyTuple} from './source/readonly-tuple.d.ts';
 export type {OverrideProperties} from './source/override-properties.d.ts';
-export type {RenameKeys} from './source/rename-keys.d.ts';
 export type {OptionalKeysOf} from './source/optional-keys-of.d.ts';
 export type {IsOptionalKeyOf} from './source/is-optional-key-of.d.ts';
 export type {HasOptionalKeys} from './source/has-optional-keys.d.ts';
@@ -128,11 +127,13 @@ export type {UnionToTuple} from './source/union-to-tuple.d.ts';
 export type {IntRange} from './source/int-range.d.ts';
 export type {IntClosedRange} from './source/int-closed-range.d.ts';
 export type {IsEqual} from './source/is-equal.d.ts';
-export type {IsLiteral} from './source/is-literal.d.ts';
-export type {IsStringLiteral} from './source/is-string-literal.d.ts';
-export type {IsNumericLiteral} from './source/is-numeric-literal.d.ts';
-export type {IsBooleanLiteral} from './source/is-boolean-literal.d.ts';
-export type {IsSymbolLiteral} from './source/is-symbol-literal.d.ts';
+export type {
+	IsLiteral,
+	IsStringLiteral,
+	IsNumericLiteral,
+	IsBooleanLiteral,
+	IsSymbolLiteral,
+} from './source/is-literal.d.ts';
 export type {IsAny} from './source/is-any.d.ts';
 export type {IfAny} from './source/if-any.d.ts';
 export type {IsNever} from './source/is-never.d.ts';

package/node_modules/type-fest/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "5.9.0",
+	"version": "5.8.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/node_modules/type-fest/readme.md

@@ -121,7 +121,6 @@ Click the type names for complete docs.
 - [`MergeDeep`](source/merge-deep.d.ts) - Merge two objects or two arrays/tuples recursively into a new type.
 - [`MergeExclusive`](source/merge-exclusive.d.ts) - Create a type that has mutually exclusive keys.
 - [`OverrideProperties`](source/override-properties.d.ts) - Override existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.
-- [`RenameKeys`](source/rename-keys.d.ts) - Rename keys in an object type according to a map of old-to-new names.
 - [`RequireAtLeastOne`](source/require-at-least-one.d.ts) - Create a type that requires at least one of the given keys, while keeping the remaining keys as is.
 - [`RequireExactlyOne`](source/require-exactly-one.d.ts) - Create a type that requires exactly one of the given keys and disallows more, while keeping the remaining keys as is.
 - [`RequireAllOrNone`](source/require-all-or-none.d.ts) - Create a type that requires all of the given keys or none of the given keys, while keeping the remaining keys as is.
@@ -165,7 +164,7 @@ Click the type names for complete docs.
 - [`SetParameterType`](source/set-parameter-type.d.ts) - Create a function that replaces some parameters with the given parameters.
 - [`Simplify`](source/simplify.d.ts) - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 - [`SimplifyDeep`](source/simplify-deep.d.ts) - Deeply simplifies an object type.
-- [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs#get) function.
+- [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 - [`KeyAsString`](source/key-as-string.d.ts) - Get keys of the given type as strings.
 - [`Schema`](source/schema.d.ts) - Create a deep version of another object type where property values are recursively replaced into a given value type.
 - [`Exact`](source/exact.d.ts) - Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared.
@@ -216,10 +215,10 @@ Click the type names for complete docs.
 
 - [`If`](source/if.d.ts) - An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 - [`IsLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-- [`IsStringLiteral`](source/is-string-literal.d.ts) - Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-- [`IsNumericLiteral`](source/is-numeric-literal.d.ts) - Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-- [`IsBooleanLiteral`](source/is-boolean-literal.d.ts) - Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
-- [`IsSymbolLiteral`](source/is-symbol-literal.d.ts) - Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+- [`IsStringLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+- [`IsNumericLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `number` or `bigint` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+- [`IsBooleanLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `true` or `false` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+- [`IsSymbolLiteral`](source/is-literal.d.ts) - Returns a boolean for whether the given type is a `symbol` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 - [`IsAny`](source/is-any.d.ts) - Returns a boolean for whether the given type is `any`.
 - [`IsNever`](source/is-never.d.ts) - Returns a boolean for whether the given type is `never`.
 - [`IsUnknown`](source/is-unknown.d.ts) - Returns a boolean for whether the given type is `unknown`.

package/node_modules/type-fest/source/delimiter-case.d.ts

@@ -1,5 +1,5 @@
 import type {ApplyDefaultOptions, AsciiPunctuation, StartsWith} from './internal/index.d.ts';
-import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
 import type {Merge} from './merge.d.ts';
 import type {_DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
 

package/node_modules/type-fest/source/get.d.ts

@@ -161,7 +161,7 @@ type PropertyOf<BaseType, Key extends string, Options extends Required<GetOption
 
 // This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
 /**
-Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs#get) function.
+Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 
 Use-case: Retrieve a property from deep inside an API response or some other complex object.
 

package/node_modules/type-fest/source/internal/object.d.ts

@@ -7,9 +7,8 @@ import type {IsAny} from '../is-any.d.ts';
 import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {StringToNumber} from '../string-to-number.d.ts';
-import type {Primitive} from '../primitive.d.ts';
 import type {FilterDefinedKeys, FilterOptionalKeys} from './keys.d.ts';
-import type {IfNotAnyOrNever, MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
+import type {MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
 import type {ToString} from './string.d.ts';
 
 /**
@@ -275,34 +274,6 @@ export type CollapseLiterals<T> = {} extends T
 		? U
 		: T;
 
-/**
-Returns the base type of a branded type.
-
-@example
-```
-type Brand = {readonly __brand: unique symbol};
-
-type A = UnwrapBrand<string & Brand>;
-//=> string
-
-type B = UnwrapBrand<number & Brand>;
-//=> number
-
-type C = UnwrapBrand<PropertyKey & Brand>;
-//=> PropertyKey
-
-type D = UnwrapBrand<(1 | 200n | 'foo' | 'bar') & Brand>;
-//=> 1 | 200n | 'foo' | 'bar'
-```
-*/
-export type UnwrapBrand<T> = IfNotAnyOrNever<T, {ifNot: _UnwrapBrand<T, Primitive>}>;
-
-type _UnwrapBrand<T, Base> = T extends Primitive
-	? T extends infer U & Pick<T, Exclude<keyof T, KeysOfUnion<Base>>>
-		? U
-		: T
-	: T;
-
 /**
 Normalize keys by including string and number representations wherever applicable.