Move local modules into a folder named Modules.

Modules/Parser/Sources/Parser/Feeds/FeedParser.swift

@@ -0,0 +1,76 @@
+//
+//  FeedParser.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/20/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import ParserObjC
+
+// FeedParser handles RSS, Atom, JSON Feed, and RSS-in-JSON.
+// You don’t need to know the type of feed.
+
+public struct FeedParser {
+
+	public static func canParse(_ parserData: ParserData) -> Bool {
+
+		let type = feedType(parserData)
+
+		switch type {
+		case .jsonFeed, .rssInJSON, .rss, .atom:
+			return true
+		default:
+			return false
+		}
+	}
+
+	public static func parse(_ parserData: ParserData) async throws -> ParsedFeed? {
+
+		let type = feedType(parserData)
+
+		switch type {
+
+		case .jsonFeed:
+			return try JSONFeedParser.parse(parserData)
+
+		case .rssInJSON:
+			return try RSSInJSONParser.parse(parserData)
+
+		case .rss:
+			return RSSParser.parse(parserData)
+
+		case .atom:
+			return AtomParser.parse(parserData)
+
+		case .unknown, .notAFeed:
+			return nil
+		}
+	}
+
+	/// For unit tests measuring performance.
+	public static func parseSync(_ parserData: ParserData) throws -> ParsedFeed? {
+
+		let type = feedType(parserData)
+
+		switch type {
+
+		case .jsonFeed:
+			return try JSONFeedParser.parse(parserData)
+
+		case .rssInJSON:
+			return try RSSInJSONParser.parse(parserData)
+
+		case .rss:
+			return RSSParser.parse(parserData)
+
+		case .atom:
+			return AtomParser.parse(parserData)
+
+		case .unknown, .notAFeed:
+			return nil
+		}
+	}
+
+}

Modules/Parser/Sources/Parser/Feeds/FeedParserError.swift

@@ -0,0 +1,29 @@
+//
+//  FeedParserError.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/24/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public struct FeedParserError: Error, Sendable {
+
+	public enum FeedParserErrorType: Sendable {
+
+		case rssChannelNotFound
+		case rssItemsNotFound
+		case jsonFeedVersionNotFound
+		case jsonFeedItemsNotFound
+		case jsonFeedTitleNotFound
+		case invalidJSON
+	}
+
+	public let errorType: FeedParserErrorType
+
+	public init(_ errorType: FeedParserErrorType) {
+
+		self.errorType = errorType
+	}
+}

Modules/Parser/Sources/Parser/Feeds/FeedType.swift

@@ -0,0 +1,64 @@
+//
+//  FeedType.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/20/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+#if SWIFT_PACKAGE
+import ParserObjC
+#endif
+
+public enum FeedType: Sendable {
+	case rss
+	case atom
+	case jsonFeed
+	case rssInJSON
+	case unknown
+	case notAFeed
+}
+
+
+private let minNumberOfBytesRequired = 128
+
+public func feedType(_ parserData: ParserData, isPartialData: Bool = false) -> FeedType {
+
+	// Can call with partial data — while still downloading, for instance.
+	// If there’s not enough data, return .unknown. Ask again when there’s more data.
+	// If it’s definitely not a feed, return .notAFeed.
+	//
+	// This is fast enough to call on the main thread.
+
+	if parserData.data.count < minNumberOfBytesRequired {
+		return .unknown
+	}
+
+	let nsdata = parserData.data as NSData
+
+	if nsdata.isProbablyJSONFeed() {
+		return .jsonFeed
+	}
+	if nsdata.isProbablyRSSInJSON() {
+		return .rssInJSON
+	}
+	if nsdata.isProbablyRSS() {
+		return .rss
+	}
+	if nsdata.isProbablyAtom() {
+		return .atom
+	}
+
+	if isPartialData && nsdata.isProbablyJSON() {
+		// Might not be able to detect a JSON Feed without all data.
+		// Dr. Drang’s JSON Feed (see althis.json and allthis-partial.json in tests)
+		// has, at this writing, the JSON version element at the end of the feed,
+		// which is totally legal — but it means not being able to detect
+		// that it’s a JSON Feed without all the data.
+		// So this returns .unknown instead of .notAFeed.
+		return .unknown
+	}
+
+	return .notAFeed
+}

Modules/Parser/Sources/Parser/Feeds/JSON/JSONFeedParser.swift

@@ -0,0 +1,250 @@
+//
+//  JSONFeedParser.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/25/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+#if SWIFT_PACKAGE
+import ParserObjC
+#endif
+
+// See https://jsonfeed.org/version/1.1
+
+public struct JSONFeedParser {
+
+	struct Key {
+		static let version = "version"
+		static let items = "items"
+		static let title = "title"
+		static let homePageURL = "home_page_url"
+		static let feedURL = "feed_url"
+		static let feedDescription = "description"
+		static let nextURL = "next_url"
+		static let icon = "icon"
+		static let favicon = "favicon"
+		static let expired = "expired"
+		static let author = "author"
+		static let authors = "authors"
+		static let name = "name"
+		static let url = "url"
+		static let avatar = "avatar"
+		static let hubs = "hubs"
+		static let type = "type"
+		static let contentHTML = "content_html"
+		static let contentText = "content_text"
+		static let externalURL = "external_url"
+		static let summary = "summary"
+		static let image = "image"
+		static let bannerImage = "banner_image"
+		static let datePublished = "date_published"
+		static let dateModified = "date_modified"
+		static let tags = "tags"
+		static let uniqueID = "id"
+		static let attachments = "attachments"
+		static let mimeType = "mime_type"
+		static let sizeInBytes = "size_in_bytes"
+		static let durationInSeconds = "duration_in_seconds"
+		static let language = "language"
+	}
+
+	static let jsonFeedVersionMarker = "://jsonfeed.org/version/" // Allow for the mistake of not getting the scheme exactly correct.
+
+	public static func parse(_ parserData: ParserData) throws -> ParsedFeed? {
+
+		guard let d = JSONUtilities.dictionary(with: parserData.data) else {
+			throw FeedParserError(.invalidJSON)
+		}
+
+		guard let version = d[Key.version] as? String, let _ = version.range(of: JSONFeedParser.jsonFeedVersionMarker) else {
+			throw FeedParserError(.jsonFeedVersionNotFound)
+		}
+		guard let itemsArray = d[Key.items] as? JSONArray else {
+			throw FeedParserError(.jsonFeedItemsNotFound)
+		}
+		guard let title = d[Key.title] as? String else {
+			throw FeedParserError(.jsonFeedTitleNotFound)
+		}
+
+		let authors = parseAuthors(d)
+		let homePageURL = d[Key.homePageURL] as? String
+		let feedURL = d[Key.feedURL] as? String ?? parserData.url
+		let feedDescription = d[Key.feedDescription] as? String
+		let nextURL = d[Key.nextURL] as? String
+		let iconURL = d[Key.icon] as? String
+		let faviconURL = d[Key.favicon] as? String
+		let expired = d[Key.expired] as? Bool ?? false
+		let hubs = parseHubs(d)
+		let language = d[Key.language] as? String
+
+		let items = parseItems(itemsArray, parserData.url)
+
+		return ParsedFeed(type: .jsonFeed, title: title, homePageURL: homePageURL, feedURL: feedURL, language: language, feedDescription: feedDescription, nextURL: nextURL, iconURL: iconURL, faviconURL: faviconURL, authors: authors, expired: expired, hubs: hubs, items: items)
+	}
+}
+
+private extension JSONFeedParser {
+
+	static func parseAuthors(_ dictionary: JSONDictionary) -> Set<ParsedAuthor>? {
+
+		if let authorsArray = dictionary[Key.authors] as? JSONArray {
+			var authors = Set<ParsedAuthor>()
+			for author in authorsArray {
+				if let parsedAuthor = parseAuthor(author) {
+					authors.insert(parsedAuthor)
+				}
+			}
+			return authors
+		}
+
+		guard let authorDictionary = dictionary[Key.author] as? JSONDictionary,
+			  let parsedAuthor = parseAuthor(authorDictionary) else {
+			return nil
+		}
+
+		return Set([parsedAuthor])
+	}
+
+	static func parseAuthor(_ dictionary: JSONDictionary) -> ParsedAuthor? {
+		let name = dictionary[Key.name] as? String
+		let url = dictionary[Key.url] as? String
+		let avatar = dictionary[Key.avatar] as? String
+		if name == nil && url == nil && avatar == nil {
+			return nil
+		}
+		return ParsedAuthor(name: name, url: url, avatarURL: avatar, emailAddress: nil)
+	}
+
+	static func parseHubs(_ dictionary: JSONDictionary) -> Set<ParsedHub>? {
+
+		guard let hubsArray = dictionary[Key.hubs] as? JSONArray else {
+			return nil
+		}
+
+		let hubs = hubsArray.compactMap { (hubDictionary) -> ParsedHub? in
+			guard let hubURL = hubDictionary[Key.url] as? String, let hubType = hubDictionary[Key.type] as? String else {
+				return nil
+			}
+			return ParsedHub(type: hubType, url: hubURL)
+		}
+		return hubs.isEmpty ? nil : Set(hubs)
+	}
+
+	static func parseItems(_ itemsArray: JSONArray, _ feedURL: String) -> Set<ParsedItem> {
+
+		return Set(itemsArray.compactMap { (oneItemDictionary) -> ParsedItem? in
+			return parseItem(oneItemDictionary, feedURL)
+		})
+	}
+
+	static func parseItem(_ itemDictionary: JSONDictionary, _ feedURL: String) -> ParsedItem? {
+
+		guard let uniqueID = parseUniqueID(itemDictionary) else {
+			return nil
+		}
+
+		let contentHTML = itemDictionary[Key.contentHTML] as? String
+		let contentText = itemDictionary[Key.contentText] as? String
+		if contentHTML == nil && contentText == nil {
+			return nil
+		}
+
+		let url = itemDictionary[Key.url] as? String
+		let externalURL = itemDictionary[Key.externalURL] as? String
+		let title = parseTitle(itemDictionary, feedURL)
+		let language = itemDictionary[Key.language] as? String
+		let summary = itemDictionary[Key.summary] as? String
+		let imageURL = itemDictionary[Key.image] as? String
+		let bannerImageURL = itemDictionary[Key.bannerImage] as? String
+
+		let datePublished = parseDate(itemDictionary[Key.datePublished] as? String)
+		let dateModified = parseDate(itemDictionary[Key.dateModified] as? String)
+
+		let authors = parseAuthors(itemDictionary)
+		var tags: Set<String>? = nil
+		if let tagsArray = itemDictionary[Key.tags] as? [String] {
+			tags = Set(tagsArray)
+		}
+		let attachments = parseAttachments(itemDictionary)
+
+		return ParsedItem(syncServiceID: nil, uniqueID: uniqueID, feedURL: feedURL, url: url, externalURL: externalURL, title: title, language: language, contentHTML: contentHTML, contentText: contentText, summary: summary, imageURL: imageURL, bannerImageURL: bannerImageURL, datePublished: datePublished, dateModified: dateModified, authors: authors, tags: tags, attachments: attachments)
+	}
+
+	static func parseTitle(_ itemDictionary: JSONDictionary, _ feedURL: String) -> String? {
+
+		guard let title = itemDictionary[Key.title] as? String else {
+			return nil
+		}
+
+		if isSpecialCaseTitleWithEntitiesFeed(feedURL) {
+			return (title as NSString).rsparser_stringByDecodingHTMLEntities()
+		}
+
+		return title
+	}
+
+	static func isSpecialCaseTitleWithEntitiesFeed(_ feedURL: String) -> Bool {
+
+		// As of 16 Feb. 2018, Kottke’s and Heer’s feeds includes HTML entities in the title elements.
+		// If we find more feeds like this, we’ll add them here. If these feeds get fixed, we’ll remove them.
+
+		let lowerFeedURL = feedURL.lowercased()
+		let matchStrings = ["kottke.org", "pxlnv.com", "macstories.net", "macobserver.com"]
+		for matchString in matchStrings {
+			if lowerFeedURL.contains(matchString) {
+				return true
+			}
+		}
+
+		return false
+	}
+
+	static func parseUniqueID(_ itemDictionary: JSONDictionary) -> String? {
+
+		if let uniqueID = itemDictionary[Key.uniqueID] as? String {
+			return uniqueID // Spec says it must be a string
+		}
+		// Version 1 spec also says that if it’s a number, even though that’s incorrect, it should be coerced to a string.
+		if let uniqueID = itemDictionary[Key.uniqueID] as? Int {
+			return "\(uniqueID)"
+		}
+		if let uniqueID = itemDictionary[Key.uniqueID] as? Double {
+			return "\(uniqueID)"
+		}
+		return nil
+	}
+
+	static func parseDate(_ dateString: String?) -> Date? {
+
+		guard let dateString = dateString, !dateString.isEmpty else {
+			return nil
+		}
+		return RSDateWithString(dateString)
+	}
+
+	static func parseAttachments(_ itemDictionary: JSONDictionary) -> Set<ParsedAttachment>? {
+
+		guard let attachmentsArray = itemDictionary[Key.attachments] as? JSONArray else {
+			return nil
+		}
+		return Set(attachmentsArray.compactMap { parseAttachment($0) })
+	}
+
+	static func parseAttachment(_ attachmentObject: JSONDictionary) -> ParsedAttachment? {
+
+		guard let url = attachmentObject[Key.url] as? String else {
+			return nil
+		}
+		guard let mimeType = attachmentObject[Key.mimeType] as? String else {
+			return nil
+		}
+
+		let title = attachmentObject[Key.title] as? String
+		let sizeInBytes = attachmentObject[Key.sizeInBytes] as? Int
+		let durationInSeconds = attachmentObject[Key.durationInSeconds] as? Int
+
+		return ParsedAttachment(url: url, mimeType: mimeType, title: title, sizeInBytes: sizeInBytes, durationInSeconds: durationInSeconds)
+	}
+}

Modules/Parser/Sources/Parser/Feeds/JSON/RSSInJSONParser.swift

@@ -0,0 +1,184 @@
+//
+//  RSSInJSONParser.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/24/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+#if SWIFT_PACKAGE
+import ParserObjC
+#endif
+
+// See https://github.com/scripting/Scripting-News/blob/master/rss-in-json/README.md
+// Also: http://cyber.harvard.edu/rss/rss.html
+
+public struct RSSInJSONParser {
+
+	public static func parse(_ parserData: ParserData) throws -> ParsedFeed? {
+
+		do {
+			guard let parsedObject = try JSONSerialization.jsonObject(with: parserData.data) as? JSONDictionary else {
+				throw FeedParserError(.invalidJSON)
+			}
+			guard let rssObject = parsedObject["rss"] as? JSONDictionary else {
+				throw FeedParserError(.rssChannelNotFound)
+			}
+			guard let channelObject = rssObject["channel"] as? JSONDictionary else {
+				throw FeedParserError(.rssChannelNotFound)
+			}
+
+			// I’d bet money that in practice the items array won’t always appear correctly inside the channel object.
+			// I’d also bet that sometimes it gets called "items" instead of "item".
+			var itemsObject = channelObject["item"] as? JSONArray
+			if itemsObject == nil {
+				itemsObject = parsedObject["item"] as? JSONArray
+			}
+			if itemsObject == nil {
+				itemsObject = channelObject["items"] as? JSONArray
+			}
+			if itemsObject == nil {
+				itemsObject = parsedObject["items"] as? JSONArray
+			}
+			if itemsObject == nil {
+				throw FeedParserError(.rssItemsNotFound)
+			}
+
+			let title = channelObject["title"] as? String
+			let homePageURL = channelObject["link"] as? String
+			let feedURL = parserData.url
+			let feedDescription = channelObject["description"] as? String
+			let feedLanguage = channelObject["language"] as? String
+
+			let items = parseItems(itemsObject!, parserData.url)
+
+			return ParsedFeed(type: .rssInJSON, title: title, homePageURL: homePageURL, feedURL: feedURL, language: feedLanguage, feedDescription: feedDescription, nextURL: nil, iconURL: nil, faviconURL: nil, authors: nil, expired: false, hubs: nil, items: items)
+
+		}
+		catch { throw error }
+	}
+}
+
+private extension RSSInJSONParser {
+
+	static func parseItems(_ itemsObject: JSONArray, _ feedURL: String) -> Set<ParsedItem> {
+
+		return Set(itemsObject.compactMap{ (oneItemDictionary) -> ParsedItem? in
+
+			return parsedItemWithDictionary(oneItemDictionary, feedURL)
+		})
+	}
+
+	static func parsedItemWithDictionary(_ itemDictionary: JSONDictionary, _ feedURL: String) -> ParsedItem? {
+
+		let externalURL = itemDictionary["link"] as? String
+		let title = itemDictionary["title"] as? String
+
+		var contentHTML = itemDictionary["description"] as? String
+		var contentText: String? = nil
+		if contentHTML != nil && !(contentHTML!.contains("<")) {
+			contentText = contentHTML
+			contentHTML = nil
+		}
+		if contentHTML == nil && contentText == nil && title == nil {
+			return nil
+		}
+
+		var datePublished: Date? = nil
+		if let datePublishedString = itemDictionary["pubDate"] as? String {
+			datePublished = RSDateWithString(datePublishedString)
+		}
+
+		let authors = parseAuthors(itemDictionary)
+		let tags = parseTags(itemDictionary)
+		let attachments = parseAttachments(itemDictionary)
+
+		var uniqueID: String? = itemDictionary["guid"] as? String
+		if uniqueID == nil {
+
+			// Calculate a uniqueID based on a combination of non-empty elements. Then hash the result.
+			// Items should have guids. When they don't, re-runs are very likely
+			// because there's no other 100% reliable way to determine identity.
+			// This calculated uniqueID is valid only for this particular feed. (Just like ids in JSON Feed.)
+
+			var s = ""
+			if let datePublished = datePublished {
+				s += "\(datePublished.timeIntervalSince1970)"
+			}
+			if let title = title {
+				s += title
+			}
+			if let externalURL = externalURL {
+				s += externalURL
+			}
+			if let authorEmailAddress = authors?.first?.emailAddress {
+				s += authorEmailAddress
+			}
+			if let oneAttachmentURL = attachments?.first?.url {
+				s += oneAttachmentURL
+			}
+			if s.isEmpty {
+				// Sheesh. Tough case.
+				if let _ = contentHTML {
+					s = contentHTML!
+				}
+				if let _ = contentText {
+					s = contentText!
+				}
+			}
+			uniqueID = (s as NSString).rsparser_md5Hash()
+		}
+
+		if let uniqueID = uniqueID {
+			return ParsedItem(syncServiceID: nil, uniqueID: uniqueID, feedURL: feedURL, url: nil, externalURL: externalURL, title: title, language: nil, contentHTML: contentHTML, contentText: contentText, summary: nil, imageURL: nil, bannerImageURL: nil, datePublished: datePublished, dateModified: nil, authors: authors, tags: tags, attachments: attachments)
+		}
+		return nil
+	}
+
+	static func parseAuthors(_ itemDictionary: JSONDictionary) -> Set<ParsedAuthor>? {
+
+		guard let authorEmailAddress = itemDictionary["author"] as? String else {
+			return nil
+		}
+		let parsedAuthor = ParsedAuthor(name: nil, url: nil, avatarURL: nil, emailAddress: authorEmailAddress)
+		return Set([parsedAuthor])
+	}
+
+	static func parseTags(_ itemDictionary: JSONDictionary) -> Set<String>? {
+
+		if let categoryObject = itemDictionary["category"] as? JSONDictionary {
+			if let oneTag = categoryObject["#value"] as? String {
+				return Set([oneTag])
+			}
+			return nil
+		}
+		else if let categoryArray = itemDictionary["category"] as? JSONArray {
+			return Set(categoryArray.compactMap{ $0["#value"] as? String })
+		}
+		return nil
+	}
+
+	static func parseAttachments(_ itemDictionary: JSONDictionary) -> Set<ParsedAttachment>? {
+
+		guard let enclosureObject = itemDictionary["enclosure"] as? JSONDictionary else {
+			return nil
+		}
+		guard let attachmentURL = enclosureObject["url"] as? String else {
+			return nil
+		}
+
+		var attachmentSize = enclosureObject["length"] as? Int
+		if attachmentSize == nil {
+			if let attachmentSizeString = enclosureObject["length"] as? String {
+				attachmentSize = (attachmentSizeString as NSString).integerValue
+			}
+		}
+
+		let type = enclosureObject["type"] as? String
+		if let attachment = ParsedAttachment(url: attachmentURL, mimeType: type, title: nil, sizeInBytes: attachmentSize, durationInSeconds: nil) {
+			return Set([attachment])
+		}
+		return nil
+	}
+}

Modules/Parser/Sources/Parser/Feeds/ParsedAttachment.swift

@@ -0,0 +1,36 @@
+//
+//  ParsedAttachment.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/20/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public struct ParsedAttachment: Hashable, Sendable {
+
+	public let url: String
+	public let mimeType: String?
+	public let title: String?
+	public let sizeInBytes: Int?
+	public let durationInSeconds: Int?
+
+	public init?(url: String, mimeType: String?, title: String?, sizeInBytes: Int?, durationInSeconds: Int?) {
+		if url.isEmpty {
+			return nil
+		}
+		
+		self.url = url
+		self.mimeType = mimeType
+		self.title = title
+		self.sizeInBytes = sizeInBytes
+		self.durationInSeconds = durationInSeconds
+	}
+
+	// MARK: - Hashable
+
+	public func hash(into hasher: inout Hasher) {
+		hasher.combine(url)
+	}
+}

Modules/Parser/Sources/Parser/Feeds/ParsedAuthor.swift

@@ -0,0 +1,44 @@
+//
+//  ParsedAuthor.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/20/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public struct ParsedAuthor: Hashable, Codable, Sendable {
+
+	public let name: String?
+	public let url: String?
+	public let avatarURL: String?
+	public let emailAddress: String?
+	
+	public init(name: String?, url: String?, avatarURL: String?, emailAddress: String?) {
+		self.name = name
+		self.url = url
+		self.avatarURL = avatarURL
+		self.emailAddress = emailAddress
+	}
+
+	// MARK: - Hashable
+
+	public func hash(into hasher: inout Hasher) {
+		if let name {
+			hasher.combine(name)
+		}
+		else if let url {
+			hasher.combine(url)
+		}
+		else if let emailAddress {
+			hasher.combine(emailAddress)
+		}
+		else if let avatarURL{
+			hasher.combine(avatarURL)
+		}
+		else {
+			hasher.combine("")
+		}
+	}
+}

Modules/Parser/Sources/Parser/Feeds/ParsedFeed.swift

@@ -0,0 +1,42 @@
+//
+//  ParsedFeed.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/20/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public struct ParsedFeed: Sendable {
+
+	public let type: FeedType
+	public let title: String?
+	public let homePageURL: String?
+	public let feedURL: String?
+	public let language: String?
+	public let feedDescription: String?
+	public let nextURL: String?
+	public let iconURL: String?
+	public let faviconURL: String?
+	public let authors: Set<ParsedAuthor>?
+	public let expired: Bool
+	public let hubs: Set<ParsedHub>?
+	public let items: Set<ParsedItem>
+
+	public init(type: FeedType, title: String?, homePageURL: String?, feedURL: String?, language: String?, feedDescription: String?, nextURL: String?, iconURL: String?, faviconURL: String?, authors: Set<ParsedAuthor>?, expired: Bool, hubs: Set<ParsedHub>?, items: Set<ParsedItem>) {
+		self.type = type
+		self.title = title
+		self.homePageURL = homePageURL?.nilIfEmptyOrWhitespace
+		self.feedURL = feedURL
+		self.language = language
+		self.feedDescription = feedDescription
+		self.nextURL = nextURL
+		self.iconURL = iconURL
+		self.faviconURL = faviconURL
+		self.authors = authors
+		self.expired = expired
+		self.hubs = hubs
+		self.items = items
+	}
+}

Modules/Parser/Sources/Parser/Feeds/ParsedHub.swift

@@ -0,0 +1,15 @@
+//
+//  ParsedHub.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/20/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public struct ParsedHub: Hashable, Sendable {
+
+	public let type: String
+	public let url: String
+}

Modules/Parser/Sources/Parser/Feeds/ParsedItem.swift

@@ -0,0 +1,67 @@
+//
+//  ParsedItem.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/20/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public struct ParsedItem: Hashable, Sendable {
+
+	public let syncServiceID: String? //Nil when not syncing
+	public let uniqueID: String //RSS guid, for instance; may be calculated
+	public let feedURL: String
+	public let url: String?
+	public let externalURL: String?
+	public let title: String?
+	public let language: String?
+	public let contentHTML: String?
+	public let contentText: String?
+	public let summary: String?
+	public let imageURL: String?
+	public let bannerImageURL: String?
+	public let datePublished: Date?
+	public let dateModified: Date?
+	public let authors: Set<ParsedAuthor>?
+	public let tags: Set<String>?
+	public let attachments: Set<ParsedAttachment>?
+	
+	public init(syncServiceID: String?, uniqueID: String, feedURL: String, url: String?, externalURL: String?, title: String?,
+				language: String?, contentHTML: String?, contentText: String?, summary: String?, imageURL: String?,
+				bannerImageURL: String?,datePublished: Date?, dateModified: Date?, authors: Set<ParsedAuthor>?,
+				tags: Set<String>?, attachments: Set<ParsedAttachment>?) {
+		
+		self.syncServiceID = syncServiceID
+		self.uniqueID = uniqueID
+		self.feedURL = feedURL
+		self.url = url
+		self.externalURL = externalURL
+		self.title = title
+		self.language = language
+		self.contentHTML = contentHTML
+		self.contentText = contentText
+		self.summary = summary
+		self.imageURL = imageURL
+		self.bannerImageURL = bannerImageURL
+		self.datePublished = datePublished
+		self.dateModified = dateModified
+		self.authors = authors
+		self.tags = tags
+		self.attachments = attachments
+	}
+
+	// MARK: - Hashable
+
+	public func hash(into hasher: inout Hasher) {
+		if let syncServiceID = syncServiceID {
+			hasher.combine(syncServiceID)
+		}
+		else {
+			hasher.combine(uniqueID)
+			hasher.combine(feedURL)
+		}
+	}
+}
+

Modules/Parser/Sources/Parser/Feeds/XML/AtomParser.swift

@@ -0,0 +1,32 @@
+//
+//  AtomParser.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/25/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+#if SWIFT_PACKAGE
+import ParserObjC
+#endif
+
+// RSSParser wraps the Objective-C RSAtomParser.
+//
+// The Objective-C parser creates RSParsedFeed, RSParsedArticle, etc.
+// This wrapper then creates ParsedFeed, ParsedItem, etc. so that it creates
+// the same things that JSONFeedParser and RSSInJSONParser create.
+//
+// In general, you should see FeedParser.swift for all your feed-parsing needs.
+
+public struct AtomParser {
+
+	public static func parse(_ parserData: ParserData) -> ParsedFeed? {
+
+		if let rsParsedFeed = RSAtomParser.parseFeed(with: parserData) {
+			return RSParsedFeedTransformer.parsedFeed(rsParsedFeed)
+		}
+		return nil
+	}
+}

Modules/Parser/Sources/Parser/Feeds/XML/RSParsedFeedTransformer.swift

@@ -0,0 +1,80 @@
+//
+//  RSParsedFeedTransformer.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/25/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+#if SWIFT_PACKAGE
+import ParserObjC
+#endif
+
+// RSRSSParser and RSAtomParser were written in Objective-C quite a while ago.
+// They create an RSParsedFeed object and related Objective-C objects.
+// These functions take an RSParsedFeed and return a Swift-y ParsedFeed,
+// which is part of providing a single API for feed parsing.
+
+struct RSParsedFeedTransformer {
+
+	static func parsedFeed(_ rsParsedFeed: RSParsedFeed) -> ParsedFeed {
+
+		let items = parsedItems(rsParsedFeed.articles)
+		return ParsedFeed(type: .rss, title: rsParsedFeed.title, homePageURL: rsParsedFeed.link, feedURL: rsParsedFeed.urlString, language: rsParsedFeed.language, feedDescription: nil, nextURL: nil, iconURL: nil, faviconURL: nil, authors: nil, expired: false, hubs: nil, items: items)
+	}
+}
+
+private extension RSParsedFeedTransformer {
+
+	static func parsedItems(_ parsedArticles: Set<RSParsedArticle>) -> Set<ParsedItem> {
+
+		// Create Set<ParsedItem> from Set<RSParsedArticle>
+
+		return Set(parsedArticles.map(parsedItem))
+	}
+
+	static func parsedItem(_ parsedArticle: RSParsedArticle) -> ParsedItem {
+
+		let uniqueID = parsedArticle.articleID
+		let url = parsedArticle.permalink
+		let externalURL = parsedArticle.link
+		let title = parsedArticle.title
+		let language = parsedArticle.language
+		let contentHTML = parsedArticle.body
+		let datePublished = parsedArticle.datePublished
+		let dateModified = parsedArticle.dateModified
+		let authors = parsedAuthors(parsedArticle.authors)
+		let attachments = parsedAttachments(parsedArticle.enclosures)
+
+		return ParsedItem(syncServiceID: nil, uniqueID: uniqueID, feedURL: parsedArticle.feedURL, url: url, externalURL: externalURL, title: title, language: language, contentHTML: contentHTML, contentText: nil, summary: nil, imageURL: nil, bannerImageURL: nil, datePublished: datePublished, dateModified: dateModified, authors: authors, tags: nil, attachments: attachments)
+	}
+
+	static func parsedAuthors(_ authors: Set<RSParsedAuthor>?) -> Set<ParsedAuthor>? {
+
+		guard let authors = authors, !authors.isEmpty else {
+			return nil
+		}
+
+		let transformedAuthors = authors.compactMap { (author) -> ParsedAuthor? in
+			return ParsedAuthor(name: author.name, url: author.url, avatarURL: nil, emailAddress: author.emailAddress)
+		}
+
+		return transformedAuthors.isEmpty ? nil : Set(transformedAuthors)
+	}
+
+	static func parsedAttachments(_ enclosures: Set<RSParsedEnclosure>?) -> Set<ParsedAttachment>? {
+
+		guard let enclosures = enclosures, !enclosures.isEmpty else {
+			return nil
+		}
+
+		let attachments = enclosures.compactMap { (enclosure) -> ParsedAttachment? in
+
+			let sizeInBytes = enclosure.length > 0 ? enclosure.length : nil
+			return ParsedAttachment(url: enclosure.url, mimeType: enclosure.mimeType, title: nil, sizeInBytes: sizeInBytes, durationInSeconds: nil)
+		}
+
+		return attachments.isEmpty ? nil : Set(attachments)
+	}
+}

Modules/Parser/Sources/Parser/Feeds/XML/RSSParser.swift

@@ -0,0 +1,29 @@
+//
+//  RSSParser.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/25/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import ParserObjC
+
+// RSSParser wraps the Objective-C RSRSSParser.
+//
+// The Objective-C parser creates RSParsedFeed, RSParsedArticle, etc.
+// This wrapper then creates ParsedFeed, ParsedItem, etc. so that it creates
+// the same things that JSONFeedParser and RSSInJSONParser create.
+//
+// In general, you should see FeedParser.swift for all your feed-parsing needs.
+
+public struct RSSParser {
+
+	public static func parse(_ parserData: ParserData) -> ParsedFeed? {
+
+		if let rsParsedFeed = RSRSSParser.parseFeed(with: parserData) {
+			return RSParsedFeedTransformer.parsedFeed(rsParsedFeed)
+		}
+		return nil
+	}
+}

Modules/Parser/Sources/Parser/JSON/JSONTypes.swift

@@ -0,0 +1,12 @@
+//
+//  JSONDictionary.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 6/24/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public typealias JSONDictionary = [String: Any]
+public typealias JSONArray = [JSONDictionary]

Modules/Parser/Sources/Parser/JSON/JSONUtilities.swift

@@ -0,0 +1,27 @@
+//
+//  JSONUtilities.swift
+//  RSParser
+//
+//  Created by Brent Simmons on 12/10/17.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+public struct JSONUtilities {
+
+	public static func object(with data: Data) -> Any? {
+
+		return try? JSONSerialization.jsonObject(with: data)
+	}
+
+	public static func dictionary(with data: Data) -> JSONDictionary? {
+
+		return object(with: data) as? JSONDictionary
+	}
+
+	public static func array(with data: Data) -> JSONArray? {
+
+		return object(with: data) as? JSONArray
+	}
+}

Modules/Parser/Sources/Parser/ParserData+Parser.swift

@@ -0,0 +1,11 @@
+//
+//  File.swift
+//  
+//
+//  Created by Brent Simmons on 4/7/24.
+//
+
+import Foundation
+import ParserObjC
+
+extension ParserData: @unchecked Sendable {}

Modules/Parser/Sources/Parser/RSHTMLMetadata+Parser.swift

@@ -0,0 +1,11 @@
+//
+//  File.swift
+//  
+//
+//  Created by Brent Simmons on 4/7/24.
+//
+
+import Foundation
+import ParserObjC
+
+extension RSHTMLMetadataParser: @unchecked Sendable {}

Modules/Parser/Sources/Parser/Utilities/String+RSParser.swift

@@ -0,0 +1,17 @@
+//
+//  String+RSParser.swift
+//  RSParser
+//
+//  Created by Nate Weaver on 2020-01-19.
+//  Copyright © 2020 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+extension String {
+
+	var nilIfEmptyOrWhitespace: String? {
+		return self.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? nil : self
+	}
+
+}