Fix typing

Author: marcospassos

Diff for: src/pointer.ts

@@ -33,13 +33,21 @@ export type ReferencedValue<T> = NestedValue<T>;
 type NestedValue<T, U = never> = T | (
     T extends object
         ? T extends U
-            ? never
+            ? NestedValue<Diff<T, U>, U>
             : T extends Array<infer I>
                 ? NestedValue<I, U | T>
-                : T[keyof T] | NestedValue<T[keyof T], U | T>
+                : NestedValue<T[keyof T], U | T>
         : never
     );
 
+type Diff<T extends object, M> = M extends infer U
+    ? T extends U
+        ? Exclude<keyof T, keyof U> extends never
+            ? never
+            : Pick<T, Exclude<keyof T, keyof U>>
+        : never
+    : never;
+
 /**
  * An error indicating a problem related to JSON pointer operations.
  */

Diff for: src/relativePointer.ts

@@ -8,7 +8,6 @@ import {
     JsonPointerLike,
     Entry,
     InvalidReferenceError,
-    RootStructure,
     ReferencedValue,
     RootValue,
 } from './pointer';
@@ -349,7 +348,7 @@ export class JsonRelativePointer implements JsonConvertible {
      *
      * @throws {InvalidReferenceError} If the pointer references the root of the structure.
      */
-    public unset<T extends RootStructure>(root: T, pointer = JsonPointer.root()): ReferencedValue<T> | undefined {
+    public unset<T extends RootValue>(root: T, pointer = JsonPointer.root()): ReferencedValue<T> | undefined {
         if (this.isKeyPointer()) {
             throw new JsonPointerError('Cannot write to a key.');
         }
@@ -358,17 +357,19 @@ export class JsonRelativePointer implements JsonConvertible {
         const remainderPointer = this.getRemainderPointer();
 
         if (!remainderPointer.isRoot()) {
-            return remainderPointer.unset(stack[stack.length - 1][1]);
+            // Given V = typeof value, and typeof value ⊆ ReferencedValue<T> → ReferencedValue<K> ⊆ ReferencedValue<T>
+            return remainderPointer.unset(stack[stack.length - 1][1]) as ReferencedValue<T>;
         }
 
         if (stack.length < 2) {
             throw new JsonPointerError('Cannot unset the root value.');
         }
 
         const segment = stack[stack.length - 1][0]!;
-        const structure = stack[stack.length - 2][1];
+        const parent = stack[stack.length - 2][1];
 
-        return JsonPointer.from([segment]).unset(structure);
+        // Given V = typeof value, and typeof value ⊆ ReferencedValue<T> → ReferencedValue<K> ⊆ ReferencedValue<T>
+        return JsonPointer.from([segment]).unset(parent) as ReferencedValue<T>;
     }
 
     /**