feat: refactor logger to standard library (#280)

* refactor: Refactor logging to use structured slog package.

- Remove `gookit` dependencies from `go.sum`
- Improve error logging in multiple packages by replacing `log` with `log/slog`
- Update dependencies in `go.mod`
- Add new `logger` package with test cases
- Refactor logging statements in multiple packages to use `slog` instead of `log`
- Change logging format and level in multiple packages for better structured logging

* refactor: Refactor logger package and add handler interface

- Refactor logger package
- Rename `defaultHandler` to `DefaultLogger`
- Move `ReplaceAttr` function to `Logger` struct
- Implement `LogHandler` struct with `slog.Handler` interface
- Add new `Logger` methods for configuration
- Add `SetMaxLevel`, `SetJSONHandler`, `SetTextHandler`, `SetOutput`, `SetVerbose`, `SetReplaceAttrFunc`
- Add verbose flag to `cmd/hack-browser-data/main.go` to increase logging

* refactor: Refactor logger package to use simplified handler initialization.

- Refactor logger package to use Default instead of DefaultLogger
- Update `NewHandler` method to correctly reference `Default` logger and simplify handler initialization
- Update tests for logger to reflect changes in Default usage
- Rename `DefaultLogger` to `Default` and update comments to better reflect its purpose
- Update function calls in hack-browser-data main.go to reflect logger package updates

* refactor: Refactor logging in Chromium implementation

Refactor logging and simplify decryption in chromium files
- Replace logger package import with shared slog package
- Change logging messages to use slog instead of logger
- Simplify decryption process by removing first 5 characters of encrypted key
- Refactor error logging in linux file to use shared slog package
- Replace string concatenation with formatted string in linux error message

logger/handler.go

@@ -0,0 +1,63 @@
+package logger
+
+import (
+	"context"
+	"log/slog"
+	"os"
+)
+
+var _ slog.Handler = (*LogHandler)(nil)
+
+// LogHandler is a slog.Handler implementation that can be used to log to a file.
+type LogHandler struct {
+	handler slog.Handler
+}
+
+func NewHandler(logger *Logger) LogHandler {
+	if logger == nil {
+		logger = Default
+	}
+
+	level := logger.Level
+	if logger.IsVerbose {
+		level = slog.LevelDebug
+	}
+
+	output := logger.Output
+	if output == nil {
+		output = os.Stderr
+	}
+
+	handlerOptions := &slog.HandlerOptions{
+		AddSource:   logger.AddSource,
+		Level:       level,
+		ReplaceAttr: logger.ReplaceAttr,
+	}
+
+	if logger.IsJSONHandler {
+		return LogHandler{
+			handler: slog.NewJSONHandler(output, handlerOptions),
+		}
+	}
+	return LogHandler{
+		handler: slog.NewTextHandler(output, handlerOptions),
+	}
+}
+
+var _ slog.Handler = (*LogHandler)(nil)
+
+func (t LogHandler) Handle(ctx context.Context, r slog.Record) error {
+	return t.handler.Handle(ctx, r)
+}
+
+func (t LogHandler) Enabled(ctx context.Context, l slog.Level) bool {
+	return t.handler.Enabled(ctx, l)
+}
+
+func (t LogHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	return LogHandler{handler: t.handler.WithAttrs(attrs)}
+}
+
+func (t LogHandler) WithGroup(name string) slog.Handler {
+	return LogHandler{handler: t.handler.WithGroup(name)}
+}