@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/MapKit/MapView.swift

@@ -0,0 +1,229 @@
+// UIKit's map (`MKMapView`), for apps that show one through a representable
+// (Apple's Food Truck puts one in a `UIViewControllerRepresentable`) and for
+// code that names it (SwiftUI-Introspect's `.introspect(.map, on: .iOS(…))`).
+// It keeps its region and settings, and its layer draws the SwiftUI `Map` of
+// this module showing that region, with its annotations as markers, so it
+// looks as a `Map` does: a surface with latitude and longitude lines, no map
+// data. Gestures do not move it; the app's own changes do.
+
+import SwiftUI
+import UIKit
+
+/// A point of view over the map: what it looks at and from how far (meters).
+open class MKMapCamera: NSObject, @unchecked Sendable {
+    public var centerCoordinate: CLLocationCoordinate2D
+    public var centerCoordinateDistance: CLLocationDistance
+    public var pitch: CGFloat
+    public var heading: CLLocationDirection
+
+    public override init() {
+        centerCoordinate = CLLocationCoordinate2D(latitude: 0, longitude: 0)
+        centerCoordinateDistance = 1000
+        pitch = 0
+        heading = 0
+    }
+
+    public init(lookingAtCenter centerCoordinate: CLLocationCoordinate2D, fromDistance distance: CLLocationDistance,
+                pitch: CGFloat, heading: CLLocationDirection) {
+        self.centerCoordinate = centerCoordinate
+        self.centerCoordinateDistance = distance
+        self.pitch = pitch
+        self.heading = heading
+    }
+
+    /// The altitude of the eye; the distance here (the browser's map has no pitch).
+    public var altitude: CLLocationDistance {
+        get { centerCoordinateDistance }
+        set { centerCoordinateDistance = newValue }
+    }
+
+    var mapCamera: MapCamera {
+        MapCamera(centerCoordinate: centerCoordinate, distance: centerCoordinateDistance, heading: heading, pitch: pitch)
+    }
+}
+
+/// How a map is drawn; kept (the browser's map is a plain surface).
+open class MKMapConfiguration: NSObject, @unchecked Sendable {
+    public enum ElevationStyle: Int, Sendable { case flat, realistic }
+    public var elevationStyle: ElevationStyle = .flat
+    public override init() {}
+}
+
+open class MKStandardMapConfiguration: MKMapConfiguration, @unchecked Sendable {
+    public enum EmphasisStyle: Int, Sendable { case `default`, muted }
+    public var emphasisStyle: EmphasisStyle = .default
+    public var pointOfInterestFilter: MKPointOfInterestFilter?
+    public var showsTraffic = false
+
+    public override init() {}
+
+    public init(elevationStyle: ElevationStyle) {
+        super.init()
+        self.elevationStyle = elevationStyle
+    }
+
+    public init(elevationStyle: ElevationStyle, emphasisStyle: EmphasisStyle) {
+        super.init()
+        self.elevationStyle = elevationStyle
+        self.emphasisStyle = emphasisStyle
+    }
+
+    public init(emphasisStyle: EmphasisStyle) {
+        super.init()
+        self.emphasisStyle = emphasisStyle
+    }
+}
+
+open class MKHybridMapConfiguration: MKMapConfiguration, @unchecked Sendable {
+    public var pointOfInterestFilter: MKPointOfInterestFilter?
+    public var showsTraffic = false
+}
+
+open class MKImageryMapConfiguration: MKMapConfiguration, @unchecked Sendable {}
+
+/// A kind of place a map may label.
+public struct MKPointOfInterestCategory: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+    public static let bakery = MKPointOfInterestCategory(rawValue: "MKPOICategoryBakery")
+    public static let cafe = MKPointOfInterestCategory(rawValue: "MKPOICategoryCafe")
+    public static let park = MKPointOfInterestCategory(rawValue: "MKPOICategoryPark")
+    public static let parking = MKPointOfInterestCategory(rawValue: "MKPOICategoryParking")
+    public static let restaurant = MKPointOfInterestCategory(rawValue: "MKPOICategoryRestaurant")
+    public static let store = MKPointOfInterestCategory(rawValue: "MKPOICategoryStore")
+}
+
+/// Which places a map labels; kept (the browser's map labels none).
+public struct MKPointOfInterestFilter: Sendable {
+    public static let includingAll = MKPointOfInterestFilter()
+    public static let excludingAll = MKPointOfInterestFilter()
+    init() {}
+    public init(including categories: [MKPointOfInterestCategory]) {}
+    public init(excluding categories: [MKPointOfInterestCategory]) {}
+}
+
+/// How a map view draws the map; kept (the browser's map is a plain surface).
+public enum MKMapType: UInt, Sendable {
+    case standard = 0
+    case satellite = 1
+    case hybrid = 2
+    case satelliteFlyover = 3
+    case hybridFlyover = 4
+    case mutedStandard = 5
+}
+
+/// Something placed on a map at a coordinate.
+public protocol MKAnnotation: AnyObject {
+    var coordinate: CLLocationCoordinate2D { get }
+    var title: String? { get }
+    var subtitle: String? { get }
+}
+
+extension MKAnnotation {
+    public var title: String? { nil }
+    public var subtitle: String? { nil }
+}
+
+/// A plain annotation with a title.
+open class MKPointAnnotation: NSObject, MKAnnotation {
+    public var coordinate: CLLocationCoordinate2D
+    public var title: String?
+    public var subtitle: String?
+
+    public override init() { coordinate = CLLocationCoordinate2D(latitude: 0, longitude: 0) }
+
+    public init(coordinate: CLLocationCoordinate2D, title: String? = nil, subtitle: String? = nil) {
+        self.coordinate = coordinate
+        self.title = title
+        self.subtitle = subtitle
+    }
+}
+
+@MainActor
+public protocol MKMapViewDelegate: AnyObject {}
+
+/// A map in a UIKit view tree, drawn as this module's SwiftUI `Map` (see the top of this file).
+@MainActor
+open class MKMapView: UIView {
+    open override class var layerClass: AnyClass { _MKMapLayer.self }
+
+    public weak var delegate: (any MKMapViewDelegate)?
+    /// The region shown: what the map draws.
+    open var region = MKCoordinateRegion.world { didSet { layer._changed() } }
+    /// Where the map looks from; setting it shows the region it sees.
+    open var camera = MKMapCamera() {
+        didSet { region = camera.mapCamera.region }
+    }
+    public var preferredConfiguration: MKMapConfiguration = MKStandardMapConfiguration()
+    open var mapType: MKMapType = .standard
+    public var pointOfInterestFilter: MKPointOfInterestFilter?
+    open var isZoomEnabled = true
+    open var isScrollEnabled = true
+    open var isPitchEnabled = true
+    open var isRotateEnabled = true
+    public var showsCompass = true
+    public var showsScale = false
+    public var showsTraffic = false
+    public var showsBuildings = true
+    open var showsUserLocation = false
+    public private(set) var annotations: [any MKAnnotation] = []
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        (layer as? _MKMapLayer)?.mapView = self
+    }
+
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        (layer as? _MKMapLayer)?.mapView = self
+    }
+
+    /// The coordinate at the center of the region.
+    open var centerCoordinate: CLLocationCoordinate2D {
+        get { region.center }
+        set { region.center = newValue }
+    }
+
+    open func setRegion(_ region: MKCoordinateRegion, animated: Bool) {
+        self.region = region
+    }
+
+    open func setCenter(_ coordinate: CLLocationCoordinate2D, animated: Bool) {
+        centerCoordinate = coordinate
+    }
+
+    open func setCamera(_ camera: MKMapCamera, animated: Bool) { self.camera = camera }
+
+    open func addAnnotation(_ annotation: any MKAnnotation) { addAnnotations([annotation]) }
+
+    open func addAnnotations(_ annotations: [any MKAnnotation]) {
+        self.annotations += annotations
+        layer._changed()
+    }
+
+    open func removeAnnotation(_ annotation: any MKAnnotation) { removeAnnotations([annotation]) }
+
+    open func removeAnnotations(_ annotations: [any MKAnnotation]) {
+        self.annotations.removeAll { existing in annotations.contains { $0 === existing } }
+        layer._changed()
+    }
+
+    /// The map as SwiftUI: a `Map` at the camera, the annotations as markers.
+    var drawing: AnyView {
+        let markers = annotations.enumerated().map { (index: $0.offset, coordinate: $0.element.coordinate, title: $0.element.title ?? "") }
+        return AnyView(Map(position: .constant(.region(region)), interactionModes: []) {
+            ForEach(markers, id: \.index) { marker in
+                Marker(marker.title, coordinate: marker.coordinate)
+            }
+        })
+    }
+}
+
+/// The layer of an `MKMapView`, which draws its map.
+final class _MKMapLayer: CALayer {
+    weak var mapView: MKMapView?
+
+    override var _drawing: AnyView? {
+        MainActor.assumeIsolated { mapView?.drawing }
+    }
+}

package/Sources/MobileCoreServices/MobileCoreServices.swift

@@ -0,0 +1,28 @@
+// `import MobileCoreServices` for the browser. On iOS the framework is where
+// the old `kUTType…` constants live, and importing it also brings `UTType`
+// (Gifu imports it for that), so this module re-exports
+// UniformTypeIdentifiers and declares the constants as identifier strings.
+
+@_exported import UniformTypeIdentifiers
+
+public let kUTTypeItem = UTType.item.identifier
+public let kUTTypeContent = UTType.content.identifier
+public let kUTTypeData = UTType.data.identifier
+public let kUTTypeImage = UTType.image.identifier
+public let kUTTypeJPEG = UTType.jpeg.identifier
+public let kUTTypePNG = UTType.png.identifier
+public let kUTTypeGIF = UTType.gif.identifier
+public let kUTTypeTIFF = UTType.tiff.identifier
+public let kUTTypeBMP = UTType.bmp.identifier
+public let kUTTypeScalableVectorGraphics = UTType.svg.identifier
+public let kUTTypeAudiovisualContent = UTType.audiovisualContent.identifier
+public let kUTTypeMovie = UTType.movie.identifier
+public let kUTTypeVideo = UTType.video.identifier
+public let kUTTypeMPEG4 = UTType.mpeg4Movie.identifier
+public let kUTTypeQuickTimeMovie = UTType.quickTimeMovie.identifier
+public let kUTTypeAudio = UTType.audio.identifier
+public let kUTTypeMP3 = UTType.mp3.identifier
+public let kUTTypeText = UTType.text.identifier
+public let kUTTypePlainText = UTType.plainText.identifier
+public let kUTTypeJSON = UTType.json.identifier
+public let kUTTypePDF = UTType.pdf.identifier

package/Sources/NaturalLanguage/LanguageIdentifier.swift

@@ -0,0 +1,317 @@
+// How `NLLanguageRecognizer` decides, in three steps:
+//
+// 1. Each letter belongs to a writing system (`_Script`), by its Unicode
+//    block. Digits, punctuation, symbols, emoji and URLs count for nothing.
+// 2. Each script with letters has its languages (a script of its own has
+//    one). Within a shared script every language starts from a prior and
+//    gains points for each of its most frequent words in the text and for
+//    each of its distinctive letters (ñ, ł, ő, і, پ, kana…). A word or
+//    letter that several languages share is split between them. The points
+//    become probabilities through a softmax: e^(1.5 × points), normalised. So
+//    about four of a language's common words make it ~90% likely, and a
+//    text with none of them leaves it among its neighbours.
+// 3. A language's probability is its share within its script, times the
+//    script's share of the letters, times n / (n + 0.5) for the script's n
+//    letters (three letters are not much to go on).
+//
+// It knows a few dozen words for each Latin-script language, so a long text
+// in a language it does not list (Tagalog, Esperanto) gets low, spread-out
+// probabilities rather than a confident wrong answer.
+
+import Foundation
+
+enum _LanguageIdentifier {
+    /// How sharply points turn into probability.
+    static let sharpness = 1.5
+
+    static func hypotheses(for text: String, hints: [NLLanguage: Double], constraints: Set<NLLanguage>) -> [NLLanguage: Double] {
+        // URLs carry no language.
+        let cleaned = text.split(whereSeparator: \.isWhitespace)
+            .filter { !$0.contains("://") && !$0.lowercased().hasPrefix("www.") }
+            .joined(separator: " ")
+            .lowercased()
+
+        var letterCounts: [_Script: Int] = [:]
+        for scalar in cleaned.unicodeScalars {
+            if let script = _Script(scalar) { letterCounts[script, default: 0] += 1 }
+        }
+        let total = letterCounts.values.reduce(0, +)
+        guard total > 0 else { return [:] }
+
+        let characters = Array(cleaned)
+        let words = cleaned.split { !$0.isLetter }.map(String.init)
+        var result: [NLLanguage: Double] = [:]
+        for (script, count) in letterCounts {
+            let n = Double(count)
+            let weight = n / Double(total) * n / (n + 0.5)
+            let distribution = script.group.distribution(words: words, characters: characters,
+                                                          hints: hints, constraints: constraints)
+            for (language, probability) in distribution {
+                result[language, default: 0] += weight * probability
+            }
+        }
+        return result.filter { $0.value >= 0.0001 }
+    }
+}
+
+// MARK: - Languages of a script
+
+/// The languages written in one script, with what tells them apart.
+struct _LanguageGroup: Sendable {
+    /// Each language and its prior, in points.
+    let candidates: [(NLLanguage, Double)]
+    /// Frequent words, each with the languages it is one of and the points it gives each.
+    var words: [String: [(NLLanguage, Double)]] = [:]
+    /// Distinctive letters, the same way.
+    var letters: [Character: [(NLLanguage, Double)]] = [:]
+    /// Letters known by their Unicode block (kana, Vietnamese's stacked diacritics).
+    var blocks: [(ClosedRange<UInt32>, NLLanguage, Double)] = []
+
+    init(_ candidates: [(NLLanguage, Double)]) { self.candidates = candidates }
+
+    /// `words` (space-separated) for each language; a word listed for k
+    /// languages gives each `points / k`.
+    func with(words lists: [NLLanguage: String], points: Double = 1) -> Self {
+        var copy = self
+        copy.words = Self.table(lists, points: points) { Array($0.split(separator: " ").map(String.init)) }
+        return copy
+    }
+
+    /// Distinctive letters (space-separated) for each language, like `with(words:)`.
+    func with(letters lists: [NLLanguage: String], points: Double = 0.5) -> Self {
+        var copy = self
+        for (key, entries) in Self.table(lists, points: points, split: { $0.split(separator: " ").compactMap(\.first) }) {
+            copy.letters[key, default: []] += entries
+        }
+        return copy
+    }
+
+    func with(block range: ClosedRange<UInt32>, _ language: NLLanguage, points: Double) -> Self {
+        var copy = self
+        copy.blocks.append((range, language, points))
+        return copy
+    }
+
+    private static func table<Key: Hashable>(_ lists: [NLLanguage: String], points: Double,
+                                             split: (String) -> [Key]) -> [Key: [(NLLanguage, Double)]] {
+        var owners: [Key: [NLLanguage]] = [:]
+        for (language, list) in lists {
+            for key in Set(split(list)) { owners[key, default: []].append(language) }
+        }
+        return owners.mapValues { languages in languages.map { ($0, points / Double(languages.count)) } }
+    }
+
+    func distribution(words text: [String], characters: [Character], hints: [NLLanguage: Double],
+                      constraints: Set<NLLanguage>) -> [NLLanguage: Double] {
+        let candidates = constraints.isEmpty ? self.candidates : self.candidates.filter { constraints.contains($0.0) }
+        guard !candidates.isEmpty else { return [:] }
+        if candidates.count == 1 { return [candidates[0].0: 1] }
+
+        var points = Dictionary(candidates, uniquingKeysWith: { a, _ in a })
+        func add(_ entries: [(NLLanguage, Double)]?) {
+            for (language, value) in entries ?? [] where points[language] != nil { points[language]! += value }
+        }
+        if !words.isEmpty { for word in text { add(words[word]) } }
+        if !letters.isEmpty || !blocks.isEmpty {
+            for character in characters {
+                add(letters[character])
+                if let scalar = character.unicodeScalars.first?.value {
+                    for (range, language, value) in blocks where range.contains(scalar) { add([(language, value)]) }
+                }
+            }
+        }
+
+        let smallestHint = hints.values.min() ?? 1
+        var logits = points.mapValues { _LanguageIdentifier.sharpness * $0 }
+        if !hints.isEmpty {
+            for language in logits.keys { logits[language]! += log(max(hints[language] ?? smallestHint, 1e-9)) }
+        }
+        let top = logits.values.max() ?? 0
+        let weights = logits.mapValues { exp($0 - top) }
+        let sum = weights.values.reduce(0, +)
+        return weights.mapValues { $0 / sum }
+    }
+}
+
+// MARK: - Scripts
+
+enum _Script: Hashable, Sendable {
+    case latin, greek, cyrillic, armenian, hebrew, arabic, devanagari, bengali, gurmukhi, gujarati, oriya,
+         tamil, telugu, kannada, malayalam, sinhala, thai, lao, tibetan, myanmar, georgian, hangul,
+         ethiopic, cherokee, khmer, mongolian, cjk
+
+    /// The script of a letter, or nil for anything else.
+    init?(_ scalar: Unicode.Scalar) {
+        guard scalar.properties.isAlphabetic else { return nil }
+        switch scalar.value {
+        case 0x41...0x5A, 0x61...0x7A, 0xAA, 0xBA, 0xC0...0x24F, 0x1E00...0x1EFF, 0x2C60...0x2C7F,
+             0xA720...0xA7FF, 0xFF21...0xFF3A, 0xFF41...0xFF5A: self = .latin
+        case 0x370...0x3FF, 0x1F00...0x1FFF: self = .greek
+        case 0x400...0x52F, 0x1C80...0x1C8F, 0x2DE0...0x2DFF, 0xA640...0xA69F: self = .cyrillic
+        case 0x530...0x58F: self = .armenian
+        case 0x590...0x5FF, 0xFB1D...0xFB4F: self = .hebrew
+        case 0x600...0x6FF, 0x750...0x77F, 0x8A0...0x8FF, 0xFB50...0xFDFF, 0xFE70...0xFEFF: self = .arabic
+        case 0x900...0x97F: self = .devanagari
+        case 0x980...0x9FF: self = .bengali
+        case 0xA00...0xA7F: self = .gurmukhi
+        case 0xA80...0xAFF: self = .gujarati
+        case 0xB00...0xB7F: self = .oriya
+        case 0xB80...0xBFF: self = .tamil
+        case 0xC00...0xC7F: self = .telugu
+        case 0xC80...0xCFF: self = .kannada
+        case 0xD00...0xD7F: self = .malayalam
+        case 0xD80...0xDFF: self = .sinhala
+        case 0xE00...0xE7F: self = .thai
+        case 0xE80...0xEFF: self = .lao
+        case 0xF00...0xFFF: self = .tibetan
+        case 0x1000...0x109F: self = .myanmar
+        case 0x10A0...0x10FF, 0x1C90...0x1CBF: self = .georgian
+        case 0x1100...0x11FF, 0x3130...0x318F, 0xAC00...0xD7AF: self = .hangul
+        case 0x1200...0x139F: self = .ethiopic
+        case 0x13A0...0x13FF, 0xAB70...0xABBF: self = .cherokee
+        case 0x1780...0x17FF: self = .khmer
+        case 0x1800...0x18AF: self = .mongolian
+        case 0x3040...0x30FF, 0x31F0...0x31FF, 0xFF66...0xFF9D, 0x3400...0x4DBF, 0x4E00...0x9FFF,
+             0xF900...0xFAFF, 0x20000...0x2FA1F: self = .cjk
+        default: return nil
+        }
+    }
+
+    var group: _LanguageGroup {
+        switch self {
+        case .latin: _Groups.latin
+        case .cyrillic: _Groups.cyrillic
+        case .arabic: _Groups.arabic
+        case .devanagari: _Groups.devanagari
+        case .cjk: _Groups.cjk
+        case .greek: _Groups.single(.greek)
+        case .armenian: _Groups.single(.armenian)
+        case .hebrew: _Groups.single(.hebrew)
+        case .bengali: _Groups.single(.bengali)
+        case .gurmukhi: _Groups.single(.punjabi)
+        case .gujarati: _Groups.single(.gujarati)
+        case .oriya: _Groups.single(.oriya)
+        case .tamil: _Groups.single(.tamil)
+        case .telugu: _Groups.single(.telugu)
+        case .kannada: _Groups.single(.kannada)
+        case .malayalam: _Groups.single(.malayalam)
+        case .sinhala: _Groups.single(.sinhalese)
+        case .thai: _Groups.single(.thai)
+        case .lao: _Groups.single(.lao)
+        case .tibetan: _Groups.single(.tibetan)
+        case .myanmar: _Groups.single(.burmese)
+        case .georgian: _Groups.single(.georgian)
+        case .hangul: _Groups.single(.korean)
+        case .ethiopic: _Groups.single(.amharic)
+        case .cherokee: _Groups.single(.cherokee)
+        case .khmer: _Groups.single(.khmer)
+        case .mongolian: _Groups.single(.mongolian)
+        }
+    }
+}
+
+// MARK: - The tables
+
+enum _Groups {
+    static func single(_ language: NLLanguage) -> _LanguageGroup { _LanguageGroup([(language, 0)]) }
+
+    static let latin = _LanguageGroup([
+        (.english, 0), (.french, 0), (.german, 0), (.spanish, 0), (.italian, 0), (.portuguese, 0), (.dutch, 0),
+        (.swedish, 0), (.danish, 0), (.norwegian, 0), (.finnish, 0), (.polish, 0), (.czech, 0), (.slovak, 0),
+        (.hungarian, 0), (.romanian, 0), (.turkish, 0), (.vietnamese, 0), (.indonesian, 0), (.malay, 0),
+        (.catalan, 0), (.croatian, 0), (.icelandic, 0),
+    ])
+    .with(words: [
+        .english: "i a one when up no more some them his her him who which how now time very really the and of to is in that it you for was with on are this have be not but they at what my just so we he she from has will can about there an or your me do if would all been were their our out like get",
+        .french: "pas ai as ont suis es on y ça cela mes tes ses nos vos votre notre aussi quand peut même le la les de des du un une et est en que qui dans pour pas sur au aux avec ce cette il elle je nous vous ne se sont mais ou plus très bien être avoir mon ma son sa leur ces tout fait comme été",
+        .german: "habe hast haben kein keine uns unser sehr schon mal jetzt hier was man heute dann doch ganz gibt diese dieser der die das und ist nicht ein eine ich du er sie es wir ihr mit auf für von zu den dem des auch sich im aber noch wie nur oder sind war wird bei nach kann mir mich dass einen hat",
+        .spanish: "te qué lo le les nos tengo tiene hoy quiero bien eso esto ese mis tu tus hasta desde porque donde el la los las de del que y en un una es por para con no se lo su al como más pero muy está son también yo me mi hay este esta ya cuando todo hace",
+        .italian: "ti cosa ci sei mio mia tuo tua oggi bene tutto perché quando dove questo quello fatto essere il lo la gli le di che e è un una per non in con del della sono mi ma si ho ha anche più questo questa come nel alla ci io molto sei",
+        .portuguese: "te meu minha seu sua hoje bem tudo porque quando onde aqui agora ainda sim vou vai o a os as de do da dos das que e é um uma em no na para com não por se mais mas como eu você ele ela isso muito está são foi tem nos ao também",
+        .dutch: "ben bent hebben heeft mijn jouw zijn haar ons onze hier daar waar hoe veel goed maken de het een en van ik je dat is niet op te zijn met voor er maar ook die wat als aan hij ze we nog naar wel dit heb kan om bij geen door nu zo",
+        .swedish: "mig dig vad hur där inget något vara blir bli kommer skulle och att det som en ett är på för med jag inte har av till den de om vi men du kan så var från eller hon han sig mycket här nu efter också bara",
+        .danish: "ingen noget være bliver blive kommer skulle hvordan og at det som en et er på for med jeg ikke har af til den de om vi men du kan så var fra eller hun han sig meget her nu efter også bare mig dig hvad der",
+        .norwegian: "ingen noe være blir bli kommer skulle hvordan og at det som en et er på for med jeg ikke har av til den de om vi men du kan så var fra eller hun han seg veldig her nå etter også bare meg deg hva der",
+        .finnish: "ja on ei se että oli hän mutta kun niin kuin tai myös minä sinä me te he tämä joka jos nyt vain ovat olen olla mitä siitä kanssa",
+        .polish: "mam masz ma jesteś jak gdzie kiedy dlaczego bo może nawet też jeszcze i w z na nie się to jest że do o jak ale po co tak za od jestem mnie już tylko czy ten są był bardzo przez dla",
+        .czech: "mám máš má jsi kde kdy proč protože může ještě tady a v se na je to že s z do o jak ale po co tak za od jsem mě už jen nebo ten jsou byl velmi pro také který není",
+        .slovak: "mám máš má si kde kedy prečo pretože môže ešte tu a v sa na je to že s z do o ako ale po čo tak za od som ma už len alebo ten sú bol veľmi pre aj ktorý nie",
+        .hungarian: "a az és hogy nem egy is van meg de ez el csak már még mint ki mi volt vagy nagyon kell lesz minden sem ha én te",
+        .romanian: "și şi de la în cu nu să pe ce din o un care mai este a sunt pentru dar am fost foarte acest această ei eu tu",
+        .turkish: "bana sana benim senin şimdi burada bugün nasıl neden ve bir bu da de için ne ile çok ama gibi daha var yok ben sen o biz onu mi mı değil olan kadar şey en her",
+        .vietnamese: "và của là có không được cho người trong những một các này với đã để khi tôi bạn đó từ cũng như rất về",
+        .indonesian: "dan yang di ke dari ini itu untuk dengan tidak ada saya kamu akan juga atau sudah bisa kita mereka karena pada dalam lebih tapi apa",
+        .malay: "dan yang di ke dari ini itu untuk dengan tidak ada saya anda akan juga atau sudah boleh kita mereka kerana pada dalam lebih tetapi apa",
+        .catalan: "el la els les de del i que en un una és per amb no es al com més però molt aquest aquesta jo hi ha són també seu",
+        .croatian: "i u je se na da za su od sa s ne to kao ali što ili ja ti smo ste bi bio sam iz po već samo jako",
+        .icelandic: "og að er í á ekki það sem til um við með ég hann hún en var af fyrir eru þetta þú hafa",
+    ])
+    .with(letters: [
+        .german: "ß ä ö ü",
+        .french: "à â ç è é ê ë î ï ô œ ù û ÿ",
+        .spanish: "á é í ñ ó ú ü ¿ ¡",
+        .portuguese: "á â ã à ç é ê í ó ô õ ú",
+        .italian: "à è é ì ò ù",
+        .catalan: "à ç è é í ï ò ó ú ü ·",
+        .polish: "ą ć ę ł ń ó ś ź ż",
+        .czech: "á č ď é ě í ň ó ř š ť ú ů ý ž",
+        .slovak: "á ä č ď é í ĺ ľ ň ó ô ŕ š ť ú ý ž",
+        .hungarian: "á é í ó ö ő ú ü ű",
+        .romanian: "ă â î ș ț ş ţ",
+        .turkish: "ç ğ ı ö ş ü â",
+        .swedish: "å ä ö",
+        .danish: "å æ ø",
+        .norwegian: "å æ ø",
+        .finnish: "ä ö",
+        .icelandic: "á æ é í ð ó ö þ ú ý",
+        .croatian: "č ć đ š ž",
+        .vietnamese: "à á â ã è é ê ì í ò ó ô õ ù ú ý ă đ ơ ư",
+    ])
+    .with(block: 0x1EA0...0x1EF9, .vietnamese, points: 0.5)
+
+    static let cyrillic = _LanguageGroup([(.russian, 2), (.ukrainian, 0), (.bulgarian, 0), (.kazakh, 0), (.mongolian, 0)])
+        .with(words: [
+            .russian: "и в не на что я с это как он а то все по но мы ты так его для у же вы бы мне меня был она они от",
+            .ukrainian: "і й та що не на це як з у в я але він ми ти для від до так його вже ви б мені мене був вона вони",
+            .bulgarian: "и в на не да се е за от че това като по са но ще с ти аз ние той тя бе съм",
+            .kazakh: "және мен бұл да де деп бір үшін ол біз сен жоқ бар емес",
+            .mongolian: "болон нь энэ би бид та юу байна байгаа гэж ч бол",
+        ])
+        .with(letters: [
+            .russian: "ы э ё",
+            .ukrainian: "і ї є ґ",
+            .bulgarian: "ъ",
+            .kazakh: "ә ғ қ ң ө ұ ү һ і ы э",
+            .mongolian: "ө ү ы э ё",
+        ])
+
+    static let arabic = _LanguageGroup([(.arabic, 2), (.persian, 0), (.urdu, 0)])
+        .with(words: [
+            .arabic: "في من على إلى أن هذا التي الذي عن مع كان ما لا هو هي و",
+            .persian: "و در به از که این را با است برای آن می یک هم",
+            .urdu: "کے میں کی ہے اور سے کو یہ نہیں ہیں پر کا ایک",
+        ])
+        .with(letters: [
+            .arabic: "ة ي ك ى إ أ ؤ ئ",
+            .persian: "پ چ ژ گ ی ک",
+            .urdu: "پ چ ژ گ ی ک ٹ ڈ ڑ ں ے ھ ۓ",
+        ])
+
+    static let devanagari = _LanguageGroup([(.hindi, 2), (.marathi, 0)])
+        .with(words: [
+            .hindi: "है के में की और का को से नहीं यह हैं भी पर था",
+            .marathi: "आहे आणि च्या ला नाही हे या मी आहेत तर पण",
+        ])
+        .with(letters: [.marathi: "ळ"])
+
+    /// Han and kana. Kana is Japanese; Han characters that differ between
+    /// the two Chinese scripts tell them apart (Japanese shares many simplified forms).
+    static let cjk = _LanguageGroup([(.simplifiedChinese, 1), (.traditionalChinese, 0), (.japanese, 0)])
+        .with(letters: [
+            .simplifiedChinese: "们 这 说 来 时 个 国 会 为 对 后 发 过 学 没 还 么 现 开 见 长 门 问 间 关 东 车 书 从 电 话 让 给 进 认 应 实 经 动 与 业 头 样 点 万 气 马 听 买 卖 爱 觉 写 读 难 边",
+            .traditionalChinese: "們 這 說 來 時 個 國 會 為 對 後 發 過 學 沒 還 麼 現 開 見 長 門 問 間 關 東 車 書 從 電 話 讓 給 進 認 應 實 經 動 與 業 頭 樣 點 萬 氣 馬 聽 買 賣 愛 覺 寫 讀 難 邊",
+        ], points: 2)
+        .with(block: 0x3040...0x30FF, .japanese, points: 1)
+        .with(block: 0x31F0...0x31FF, .japanese, points: 1)
+        .with(block: 0xFF66...0xFF9D, .japanese, points: 1)
+}