assertArgumentNotNull("fromClass", fromClass);

        if (toClass == Object.class && !fromClass.isPrimitive()) {
            return true;
        }
        if (toClass.isPrimitive()) {
            fromClass = getPrimitiveClassIfWrapper(fromClass);
        }
        return toClass.isAssignableFrom(fromClass);
    }

    /**
     * Converts a wrapper class to its corresponding primitive class.
     *

			return nil
		}
		data, err := os.ReadFile(path)
		if err != nil {
			log.Fatal(err)
		}
		if strings.HasSuffix(path, ".zip") {
			log.Fatalf("unexpected file during walk: %s", path)
		}
		name := filepath.ToSlash(path)
		w, err := zw.CreateRaw(&zip.FileHeader{
			Name:               name,
			Method:             zip.Store,
			CompressedSize64:   uint64(len(data)),
			UncompressedSize64: uint64(len(data)),

}

func sourceDir(file string) string {
	dir := filepath.Dir(file)
	dir = filepath.Dir(dir)

	s := filepath.Dir(dir)
	if filepath.Base(s) != "gorm.io" {
		s = dir
	}
	return filepath.ToSlash(s) + "/"
}

// CallerFrame retrieves the first relevant stack frame outside of GORM's internal implementation files.
// It skips:
//   - GORM's core source files (identified by gormSourceDir prefix)

}

func trimTrace(f string) string {
	for _, trimString := range trimStrings {
		f = strings.TrimPrefix(filepath.ToSlash(f), filepath.ToSlash(trimString))
	}
	return filepath.FromSlash(f)
}

func getSource(level int) string {
	pc, file, lineNumber, ok := runtime.Caller(level)
	if ok {
		// Clean up the common prefixes

HSPLokio/internal/_PathKt;->getSlash(Lokio/Path;)Lokio/ByteString;
HSPLokio/internal/_PathKt;->toPath(Lokio/Buffer;Z)Lokio/Path;
HSPLokio/internal/_PathKt;->toSlash(B)Lokio/ByteString;
HSPLokio/internal/_PathKt;->toSlash(Ljava/lang/String;)Lokio/ByteString;
Landroidx/activity/ComponentActivity$$ExternalSyntheticLambda0;
Landroidx/activity/ComponentActivity$$ExternalSyntheticLambda1;

		return
	}
	file := r.Form.Get("file")
	if len(file) == 0 {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInvalidRequest), r.URL)
		return
	}

	file = filepath.ToSlash(file)
	// Reject attempts to traverse parent or absolute paths.
	if hasBadPathComponent(volume) || hasBadPathComponent(file) {
		writeErrorResponse(r.Context(), w, errorCodes.ToAPIErr(ErrInvalidResourceName), r.URL)

				}
			}
			return stat, errPathNotFound
		}
		name, err := filepath.Rel(volumeDir, filePath)
		if err != nil {
			name = filePath
		}
		stat = append(stat, StatInfo{
			Name:    filepath.ToSlash(name),
			Size:    st.Size(),
			Dir:     st.IsDir(),
			Mode:    uint32(st.Mode()),
			ModTime: st.ModTime(),
		})
	}
	return stat, nil
}

pkg path/filepath, func Rel(string, string) (string, error)
pkg path/filepath, func Split(string) (string, string)
pkg path/filepath, func SplitList(string) []string
pkg path/filepath, func ToSlash(string) string
pkg path/filepath, func VolumeName(string) string
pkg path/filepath, func Walk(string, WalkFunc) error
pkg path/filepath, type WalkFunc func(string, os.FileInfo, error) error