fix: added guard for edge case causing potential panic

expander.go

@@ -527,72 +527,75 @@
 	return ref, sch, nil
 }
 
 func expandParameterOrResponse(input any, resolver *schemaLoader, basePath string) error {
 	ref, sch, err := getRefAndSchema(input)
 	if err != nil {
 		return err
 	}
 
 	if ref == nil && sch == nil { // nothing to do
 		return nil
 	}
 
 	parentRefs := make([]string, 0, smallPrealloc)
 	if ref != nil {
 		// dereference this $ref
 		if err = resolver.deref(input, parentRefs, basePath); resolver.shouldStopOnError(err) {
 			return err
 		}
 
 		ref, sch, _ = getRefAndSchema(input)
+		if ref == nil {
+			ref = &Ref{} // empty ref
+		}
 	}
 
 	if ref.String() != "" {
 		transitiveResolver := resolver.transitiveResolver(basePath, *ref)
 		basePath = resolver.updateBasePath(transitiveResolver, basePath)
 		resolver = transitiveResolver
 	}
 
 	if sch == nil {
 		// nothing to be expanded
 		if ref != nil {
 			*ref = Ref{}
 		}
 
 		return nil
 	}
 
 	if sch.Ref.String() != "" {
 		rebasedRef, ern := NewRef(normalizeURI(sch.Ref.String(), basePath))
 		if ern != nil {
 			return ern
 		}
 
 		if resolver.isCircular(&rebasedRef, basePath, parentRefs...) {
 			// this is a circular $ref: stop expansion
 			if !resolver.options.AbsoluteCircularRef {
 				sch.Ref = denormalizeRef(&rebasedRef, resolver.context.basePath, resolver.context.rootID)
 			} else {
 				sch.Ref = rebasedRef
 			}
 		}
 	}
 
 	// $ref expansion or rebasing is performed by expandSchema below
 	if ref != nil {
 		*ref = Ref{}
 	}
 
 	// expand schema
 	// yes, we do it even if options.SkipSchema is true: we have to go down that rabbit hole and rebase nested $ref)
 	s, err := expandSchema(*sch, parentRefs, resolver, basePath)
 	if resolver.shouldStopOnError(err) {
 		return err
 	}
 
 	if s != nil { // guard for when continuing on error
 		*sch = *s
 	}
 
 	return nil
 }