radio-stream-extractor/internal/extractor/extractor.go

package extractor

import (
    "regexp"
    "sort"
    "strings"
)

var urlPattern = regexp.MustCompile(`(?i)((?:https?:)?\/\/[^\s"'<>]+\.(mp3|aac|m3u8|ogg|opus|pls|m3u|xspf|json))`)
var attrPattern = regexp.MustCompile(`(?i)(streamsrc|streamhash|stream|audioUrl|mp3Url|hls|playlist|source)\s*[:=]\s*['"]([^'"]+)['"]`)
var srcPattern = regexp.MustCompile(`(?i)src\s*=\s*['"]([^'"]+)['"]`)
var iframePattern = regexp.MustCompile(`(?i)<iframe[^>]+src\s*=\s*['"]([^'"]+)['"]`)
var audioPattern = regexp.MustCompile(`(?i)<audio[^>]+src\s*=\s*['"]([^'"]+)['"]`)
var sourcePattern = regexp.MustCompile(`(?i)<source[^>]+src\s*=\s*['"]([^'"]+)['"]`)
var xspfPattern = regexp.MustCompile(`(?i)<location>([^<]+)</location>`)

// ExtractStreams returns the unique streaming URLs found in the provided HTML/text.
func ExtractStreams(data string) []string {
    candidates := make(map[string]struct{})
    special := make(map[string]struct{})
    add := func(raw string) {
        if normalized, ok := normalizeCandidate(raw); ok {
            candidates[normalized] = struct{}{}
        }
    }
    addSpecial := func(raw string) {
        if normalized, ok := normalizeCandidate(raw); ok {
            candidates[normalized] = struct{}{}
            special[normalized] = struct{}{}
        }
    }

    for _, match := range urlPattern.FindAllStringSubmatch(data, -1) {
        add(match[1])
    }
    for _, match := range attrPattern.FindAllStringSubmatch(data, -1) {
        add(match[2])
    }
    for _, match := range srcPattern.FindAllStringSubmatch(data, -1) {
        add(match[1])
    }
    for _, match := range audioPattern.FindAllStringSubmatch(data, -1) {
        addSpecial(match[1])
    }
    for _, match := range sourcePattern.FindAllStringSubmatch(data, -1) {
        addSpecial(match[1])
    }

    streams := make([]string, 0, len(candidates))
    for u := range candidates {
        if isStreamURL(u) {
            streams = append(streams, u)
            continue
        }
        if _, ok := special[u]; ok {
            streams = append(streams, u)
        }
    }
    sort.Strings(streams)
    return streams
}

// ExtractPlaylistLinks returns URLs likely pointing to playlists (m3u/pls/xspf/json).
func ExtractPlaylistLinks(data string) []string {
    candidates := make(map[string]struct{})
    add := func(raw string) {
        if normalized, ok := normalizeCandidate(raw); ok && isPlaylistURL(normalized) {
            candidates[normalized] = struct{}{}
        }
    }

    for _, match := range urlPattern.FindAllStringSubmatch(data, -1) {
        add(match[1])
    }
    for _, match := range attrPattern.FindAllStringSubmatch(data, -1) {
        add(match[2])
    }
    for _, match := range srcPattern.FindAllStringSubmatch(data, -1) {
        add(match[1])
    }

    links := make([]string, 0, len(candidates))
    for u := range candidates {
        links = append(links, u)
    }
    sort.Strings(links)
    return links
}

// ExtractEmbedURLs returns URLs found in iframe embeds.
func ExtractEmbedURLs(data string) []string {
    candidates := make(map[string]struct{})
    for _, match := range iframePattern.FindAllStringSubmatch(data, -1) {
        if normalized, ok := normalizeCandidate(match[1]); ok {
            candidates[normalized] = struct{}{}
        }
    }

    urls := make([]string, 0, len(candidates))
    for u := range candidates {
        urls = append(urls, u)
    }
    sort.Strings(urls)
    return urls
}

// ParsePlaylist extracts stream URLs from playlist content.
func ParsePlaylist(content string, contentType string) []string {
    candidates := make(map[string]struct{})
    add := func(raw string) {
        raw = strings.TrimSpace(raw)
        if raw == "" {
            return
        }
        if strings.HasPrefix(raw, "//") {
            raw = "https:" + raw
        }
        if isStreamURL(raw) {
            candidates[raw] = struct{}{}
        }
    }

    lowerType := strings.ToLower(contentType)
    lines := strings.Split(content, "\n")

    if strings.Contains(lowerType, "xspf") || strings.Contains(strings.ToLower(content), "<location>") {
        for _, match := range xspfPattern.FindAllStringSubmatch(content, -1) {
            add(match[1])
        }
    }

    for _, match := range urlPattern.FindAllStringSubmatch(content, -1) {
        add(match[1])
    }

    for _, line := range lines {
        line = strings.TrimSpace(line)
        if line == "" || strings.HasPrefix(line, "#") {
            continue
        }
        if strings.HasPrefix(strings.ToLower(line), "file") && strings.Contains(line, "=") {
            parts := strings.SplitN(line, "=", 2)
            add(parts[1])
            continue
        }
        if strings.Contains(line, "http") {
            for _, match := range urlPattern.FindAllStringSubmatch(line, -1) {
                add(match[1])
            }
        }
    }

    if strings.Contains(lowerType, "json") {
        for _, match := range urlPattern.FindAllStringSubmatch(content, -1) {
            add(match[1])
        }
    }

    streams := make([]string, 0, len(candidates))
    for u := range candidates {
        streams = append(streams, u)
    }
    sort.Strings(streams)
    return streams
}

func normalizeCandidate(raw string) (string, bool) {
    raw = strings.TrimSpace(raw)
    if raw == "" {
        return "", false
    }
    if !(strings.Contains(raw, "http") || strings.HasPrefix(raw, "//")) {
        return "", false
    }
    if strings.HasPrefix(raw, "//") {
        raw = "https:" + raw
    }
    normalized := strings.TrimRight(raw, "+")
    normalized = strings.ReplaceAll(normalized, `\\`, "")
    if normalized == "" {
        return "", false
    }
    return normalized, true
}

func isStreamURL(u string) bool {
    lower := strings.ToLower(u)
    return strings.Contains(lower, ".mp3") || strings.Contains(lower, ".aac") || strings.Contains(lower, ".m3u8") ||
        strings.Contains(lower, ".ogg") || strings.Contains(lower, ".opus")
}

func isPlaylistURL(u string) bool {
    lower := strings.ToLower(u)
    return strings.Contains(lower, ".m3u") || strings.Contains(lower, ".pls") ||
        strings.Contains(lower, ".xspf") || strings.Contains(lower, ".json")
}