pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Bridge/PNTransaction.swift

@@ -0,0 +1,165 @@
+import UIKit
+
+/// Decodes and applies reconciler transactions.
+///
+/// A transaction is a JSON array of ops:
+///
+/// - `["c", tag, "Type", {props}]` create a view
+/// - `["u", tag, {changed}]` apply changed props (`null` removes a prop)
+/// - `["i", parent, child, index]` ensure `child` is at `index` under `parent`
+/// - `["d", tag]` destroy the view
+/// - `["f", tag, x, y, w, h]` set the frame in points
+///
+/// Ops are applied strictly in order; a failing op is logged and skipped
+/// so one bad prop can't desync the rest of the tree.
+public enum PNTransaction {
+    /// A decoded op.
+    public enum Op: Equatable {
+        case create(tag: Int64, type: String, props: [String: Any])
+        case update(tag: Int64, changed: [String: Any])
+        case insert(parent: Int64, child: Int64, index: Int)
+        case destroy(tag: Int64)
+        case frame(tag: Int64, x: Double, y: Double, w: Double, h: Double)
+
+        public static func == (lhs: Op, rhs: Op) -> Bool {
+            switch (lhs, rhs) {
+            case let (.create(t1, ty1, p1), .create(t2, ty2, p2)):
+                return t1 == t2 && ty1 == ty2 && NSDictionary(dictionary: p1).isEqual(to: p2)
+            case let (.update(t1, p1), .update(t2, p2)):
+                return t1 == t2 && NSDictionary(dictionary: p1).isEqual(to: p2)
+            case let (.insert(p1, c1, i1), .insert(p2, c2, i2)):
+                return p1 == p2 && c1 == c2 && i1 == i2
+            case let (.destroy(t1), .destroy(t2)):
+                return t1 == t2
+            case let (.frame(t1, x1, y1, w1, h1), .frame(t2, x2, y2, w2, h2)):
+                return t1 == t2 && x1 == x2 && y1 == y2 && w1 == w2 && h1 == h2
+            default:
+                return false
+            }
+        }
+    }
+
+    /// Errors raised while decoding a single op.
+    public enum DecodeError: Error, Equatable {
+        case notAnArray
+        case malformedOp(index: Int)
+        case unknownOpcode(String)
+    }
+
+    // MARK: - Decoding
+
+    /// Decode a transaction document into ops. Malformed ops are skipped
+    /// (and logged) rather than failing the whole batch.
+    public static func decode(_ json: String) throws -> [Op] {
+        guard let root = PNJSON.decode(json) as? [Any] else { throw DecodeError.notAnArray }
+        var ops: [Op] = []
+        ops.reserveCapacity(root.count)
+        for (index, raw) in root.enumerated() {
+            do {
+                ops.append(try decodeOp(raw, index: index))
+            } catch {
+                PNLog.rateLimited(PNLog.bridge, key: "decode-op", "skipping malformed op #\(index): \(error)")
+            }
+        }
+        return ops
+    }
+
+    static func decodeOp(_ raw: Any, index: Int) throws -> Op {
+        guard let parts = raw as? [Any], let code = parts.first as? String else {
+            throw DecodeError.malformedOp(index: index)
+        }
+        func tag(_ i: Int) throws -> Int64 {
+            guard i < parts.count, let value = PNProps.double(parts[i]), value.isFinite else {
+                throw DecodeError.malformedOp(index: index)
+            }
+            return Int64(value)
+        }
+        func number(_ i: Int) throws -> Double {
+            guard i < parts.count, let value = PNProps.double(parts[i]) else {
+                throw DecodeError.malformedOp(index: index)
+            }
+            return value
+        }
+        switch code {
+        case "c":
+            guard parts.count >= 4, let type = parts[2] as? String else { throw DecodeError.malformedOp(index: index) }
+            let props = (PNJSON.resolveInfinity(parts[3]) as? [String: Any]) ?? [:]
+            return .create(tag: try tag(1), type: type, props: props)
+        case "u":
+            guard parts.count >= 3 else { throw DecodeError.malformedOp(index: index) }
+            let changed = (PNJSON.resolveInfinity(parts[2]) as? [String: Any]) ?? [:]
+            return .update(tag: try tag(1), changed: changed)
+        case "i":
+            guard parts.count >= 4 else { throw DecodeError.malformedOp(index: index) }
+            return .insert(parent: try tag(1), child: try tag(2), index: Int(try number(3)))
+        case "d":
+            return .destroy(tag: try tag(1))
+        case "f":
+            guard parts.count >= 6 else { throw DecodeError.malformedOp(index: index) }
+            return .frame(tag: try tag(1), x: try number(2), y: try number(3), w: try number(4), h: try number(5))
+        default:
+            throw DecodeError.unknownOpcode(code)
+        }
+    }
+
+    // MARK: - Applying
+
+    /// Decode and apply a transaction document.
+    public static func apply(_ json: String) {
+        let ops: [Op]
+        do {
+            ops = try decode(json)
+        } catch {
+            PNLog.bridge.error("transaction rejected: \(String(describing: error))")
+            return
+        }
+        apply(ops)
+    }
+
+    /// Apply already-decoded ops in order with per-op error isolation.
+    public static func apply(_ ops: [Op]) {
+        let registry = PNViewRegistry.shared
+        for op in ops {
+            switch op {
+            case let .create(tag, type, props):
+                if registry.resolve(tag) != nil {
+                    PNLog.rateLimited(PNLog.bridge, key: "dup-create", "create for tag \(tag) ignored: already exists")
+                    continue
+                }
+                let manager = PNRegistry.shared.manager(for: type)
+                let view = manager.createView(tag: tag, props: props)
+                registry.register(PNViewRecord(tag: tag, typeName: type, view: view, manager: manager))
+                manager.didCreate(view: view, tag: tag, props: props)
+
+            case let .update(tag, changed):
+                guard let record = registry.resolve(tag) else {
+                    PNLog.rateLimited(PNLog.bridge, key: "missing-update", "update for unknown tag \(tag)")
+                    continue
+                }
+                record.manager.update(view: record.view, changed: changed)
+
+            case let .insert(parent, child, index):
+                guard let parentRecord = registry.resolve(parent), let childRecord = registry.resolve(child) else {
+                    PNLog.rateLimited(PNLog.bridge, key: "missing-insert", "insert \(child) into \(parent): unknown tag")
+                    continue
+                }
+                parentRecord.manager.insertChild(parent: parentRecord.view, child: childRecord.view, index: index)
+
+            case let .destroy(tag):
+                guard let record = registry.unregister(tag) else { continue }
+                if let parent = record.view.superview,
+                   let parentState = PNViewState.existing(for: parent),
+                   let parentRecord = registry.resolve(parentState.tag)
+                {
+                    parentRecord.manager.removeChild(parent: parent, child: record.view)
+                }
+                record.manager.destroy(view: record.view)
+                PNViewState.detach(record.view)
+
+            case let .frame(tag, x, y, w, h):
+                guard let record = registry.resolve(tag) else { continue }
+                record.manager.setFrame(view: record.view, x: x, y: y, w: w, h: h)
+            }
+        }
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Bridge/PNViewRegistry.swift

@@ -0,0 +1,53 @@
+import UIKit
+
+/// One live native view addressed by its reconciler tag.
+public final class PNViewRecord {
+    public let tag: Int64
+    public let typeName: String
+    public let view: UIView
+    public let manager: PNComponentManager
+
+    init(tag: Int64, typeName: String, view: UIView, manager: PNComponentManager) {
+        self.tag = tag
+        self.typeName = typeName
+        self.view = view
+        self.manager = manager
+    }
+}
+
+/// Tag -> view table. Every view created through a transaction is
+/// registered here until its `d` op arrives.
+public final class PNViewRegistry {
+    public static let shared = PNViewRegistry()
+
+    private var records: [Int64: PNViewRecord] = [:]
+
+    private init() {}
+
+    /// The record for `tag`, or `nil` when no such view exists.
+    public func resolve(_ tag: Int64) -> PNViewRecord? {
+        records[tag]
+    }
+
+    /// The registered view for `tag`.
+    public func view(for tag: Int64) -> UIView? {
+        records[tag]?.view
+    }
+
+    /// Number of live records (used by tests and diagnostics).
+    public var count: Int { records.count }
+
+    func register(_ record: PNViewRecord) {
+        records[record.tag] = record
+    }
+
+    @discardableResult
+    func unregister(_ tag: Int64) -> PNViewRecord? {
+        records.removeValue(forKey: tag)
+    }
+
+    /// Drop every record. Intended for tests.
+    public func removeAll() {
+        records.removeAll()
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Components/PNButtonManagers.swift

@@ -0,0 +1,206 @@
+import UIKit
+
+/// A closure-backed `UIControl` target with the duplicate-send filter the
+/// simulator's event injection needs (one `UIEvent`, two action sends).
+public final class PNActionTarget: NSObject {
+    private let handler: () -> Void
+    private var lastTimestamp: TimeInterval?
+
+    public init(_ handler: @escaping () -> Void) {
+        self.handler = handler
+    }
+
+    /// Attach `handler` to `control` for `events`, retained by the view's state.
+    @discardableResult
+    public static func attach(_ control: UIControl, events: UIControl.Event, _ handler: @escaping () -> Void) -> PNActionTarget {
+        let target = PNActionTarget(handler)
+        control.addTarget(target, action: #selector(fire(_:forEvent:)), for: events)
+        PNViewState.existing(for: control)?.retained.append(target)
+        return target
+    }
+
+    @objc func fire(_ sender: Any?, forEvent event: UIEvent?) {
+        if let timestamp = event?.timestamp {
+            if lastTimestamp == timestamp {
+                PNLog.once(PNLog.components, key: "control-dedupe", "dropped a duplicated control action (one UIEvent, two sends)")
+                return
+            }
+            lastTimestamp = timestamp
+        }
+        handler()
+    }
+}
+
+/// `Button`: a system `UIButton` emitting `on_press`.
+public final class PNButtonManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UIButton(type: .system)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let button = view as? UIButton {
+            PNActionTarget.attach(button, events: .touchUpInside) { [weak button] in
+                guard let button = button else { return }
+                PNEvents.emit(button, "on_press")
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let button = view as? UIButton else { return }
+        if PNProps.has(props, "title") {
+            button.setTitle(PNProps.string(PNProps.value(props, "title")) ?? "", for: .normal)
+        }
+        if let size = PNProps.double(PNProps.value(props, "font_size")) {
+            button.titleLabel?.font = UIFont.systemFont(ofSize: CGFloat(size))
+        }
+        if let color = PNColor.parse(PNProps.value(props, "background_color")) {
+            button.backgroundColor = color
+            if !PNProps.has(props, "color") {
+                button.setTitleColor(.white, for: .normal)
+            }
+        }
+        if let color = PNColor.parse(PNProps.value(props, "color")) {
+            button.setTitleColor(color, for: .normal)
+        }
+        if PNProps.has(props, "enabled") {
+            button.isEnabled = PNProps.bool(PNProps.value(props, "enabled")) ?? true
+        }
+        PNViewStyler.applyDecoration(button, props)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let intrinsic = view.intrinsicContentSize
+        var w = intrinsic.width + 24
+        var h = intrinsic.height + 12
+        if maxW.isFinite { w = min(w, maxW) }
+        if maxH.isFinite { h = min(h, maxH) }
+        return CGSize(width: max(w, 44), height: max(h, 32))
+    }
+}
+
+/// `Checkbox`: an SF Symbol button toggling checked / unchecked.
+public final class PNCheckboxManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UIButton(type: .custom)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let button = view as? UIButton {
+            PNActionTarget.attach(button, events: .touchUpInside) { [weak self, weak button] in
+                guard let self = self, let button = button else { return }
+                self.toggle(button)
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let button = view as? UIButton, let state = PNViewState.existing(for: button) else { return }
+        if initial {
+            let ink = PNColor.parse("#111111") ?? .label
+            button.setTitleColor(ink, for: .normal)
+            button.tintColor = ink
+        }
+        if PNProps.has(props, "value") {
+            state.extras["value"] = PNProps.bool(PNProps.value(props, "value")) ?? false
+        }
+        if PNProps.has(props, "label") {
+            let label = PNProps.string(PNProps.value(props, "label")) ?? ""
+            button.setTitle(label, for: .normal)
+            button.accessibilityLabel = label
+        }
+        if PNProps.has(props, "disabled") {
+            button.isEnabled = !(PNProps.bool(PNProps.value(props, "disabled")) ?? false)
+        }
+        updateImage(button)
+        PNViewStyler.applyAccessibility(button, props)
+    }
+
+    private func toggle(_ button: UIButton) {
+        guard let state = PNViewState.existing(for: button) else { return }
+        if PNProps.bool(PNProps.value(state.props, "disabled")) == true { return }
+        let newValue = !state.flag("value")
+        // Optimistic flip so the box feels instant; the `value` prop re-syncs it.
+        state.extras["value"] = newValue
+        updateImage(button)
+        PNEvents.emit(button, "on_change", [newValue])
+    }
+
+    private func updateImage(_ button: UIButton) {
+        guard let state = PNViewState.existing(for: button) else { return }
+        let checked = state.flag("value")
+        guard var image = UIImage(systemName: checked ? "checkmark.square.fill" : "square") else { return }
+        if checked, let color = PNColor.parse(PNProps.value(state.props, "color")) {
+            image = image.withTintColor(color, renderingMode: .alwaysOriginal)
+        }
+        button.setImage(image, for: .normal)
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let size = view.sizeThatFits(CGSize(width: PNComponentManager.clampConstraint(maxW), height: PNComponentManager.clampConstraint(maxH)))
+        var w = max(size.width + 8, 28)
+        if maxW.isFinite { w = min(w, maxW) }
+        return CGSize(width: w, height: max(size.height, 28))
+    }
+}
+
+/// `Picker`: a button that presents an action sheet listing the options.
+public final class PNPickerManager: PNComponentManager {
+    public override func makeView(props: [String: Any]) -> UIView {
+        UIButton(type: .system)
+    }
+
+    public override func createView(tag: Int64, props: [String: Any]) -> UIView {
+        let view = super.createView(tag: tag, props: props)
+        if let button = view as? UIButton {
+            PNActionTarget.attach(button, events: .touchUpInside) { [weak self, weak button] in
+                guard let self = self, let button = button else { return }
+                self.presentSheet(button)
+            }
+        }
+        return view
+    }
+
+    public override func apply(view: UIView, props: [String: Any], initial: Bool) {
+        guard let button = view as? UIButton else { return }
+        button.setTitle(PNPickerManager.title(for: mergedProps(button)), for: .normal)
+        PNViewStyler.applyAccessibility(button, props)
+    }
+
+    static func items(_ props: [String: Any]) -> [[String: Any]] {
+        ((PNProps.value(props, "items") as? [Any]) ?? []).compactMap { $0 as? [String: Any] }
+    }
+
+    static func title(for props: [String: Any]) -> String {
+        let selected = PNProps.value(props, "value")
+        for item in items(props) {
+            if let value = PNProps.value(item, "value"), PNJSON.encode(value) == PNJSON.encode(selected) {
+                return PNProps.string(item["label"]) ?? PNProps.string(item["value"]) ?? ""
+            }
+        }
+        return PNProps.string(PNProps.value(props, "placeholder")) ?? "Select…"
+    }
+
+    private func presentSheet(_ button: UIButton) {
+        let merged = mergedProps(button)
+        let items = PNPickerManager.items(merged)
+        var buttons: [[String: Any]] = items.map { ["label": PNProps.string($0["label"]) ?? PNProps.string($0["value"]) ?? ""] }
+        buttons.append(["label": "Cancel", "style": "cancel"])
+        PNAlertPresenter.present(
+            title: PNProps.string(PNProps.value(merged, "placeholder")) ?? "Select…",
+            message: nil, buttons: buttons, style: "action_sheet"
+        ) { index in
+            guard index >= 0, index < items.count else { return }
+            PNEvents.emit(button, "on_change", [PNProps.value(items[index], "value")])
+        }
+    }
+
+    public override func measure(view: UIView, maxW: CGFloat, maxH: CGFloat) -> CGSize {
+        let size = view.sizeThatFits(CGSize(width: PNComponentManager.clampConstraint(maxW), height: PNComponentManager.clampConstraint(maxH)))
+        return CGSize(width: size.width + 16, height: size.height + 8)
+    }
+}

pythonnative/templates/ios_template/PythonNativeKit/Sources/PythonNativeKit/Components/PNColor.swift

@@ -0,0 +1,173 @@
+import UIKit
+
+/// Color parsing shared by every manager.
+///
+/// Accepts `#RGB`, `#RGBA`, `#RRGGBB`, `#AARRGGBB` (the PythonNative
+/// convention: alpha first), `rgb(r, g, b)`, `rgba(r, g, b, a)`, CSS
+/// named colors, `"transparent"`, raw ARGB integers, and
+/// `{"light": c, "dark": c}` dictionaries for dynamic colors.
+public enum PNColor {
+    /// Parse `value` into a `UIColor`, or `nil` when it isn't a color.
+    public static func parse(_ value: Any?) -> UIColor? {
+        switch value {
+        case nil, is NSNull:
+            return nil
+        case let dict as [String: Any]:
+            return dynamic(dict)
+        case let number as NSNumber where !(value is Bool):
+            return fromARGB(number.int64Value)
+        case let int as Int:
+            return fromARGB(Int64(int))
+        case let string as String:
+            return parse(string: string)
+        default:
+            return nil
+        }
+    }
+
+    /// Parse a color string; see `parse(_:)` for the accepted grammar.
+    public static func parse(string raw: String) -> UIColor? {
+        let text = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        if text.isEmpty { return nil }
+        let lower = text.lowercased()
+        if lower == "transparent" || lower == "clear" || lower == "none" {
+            return UIColor.clear
+        }
+        if text.hasPrefix("#") {
+            return parseHex(String(text.dropFirst()))
+        }
+        if lower.hasPrefix("rgb") {
+            return parseRGBFunction(lower)
+        }
+        if let named = PNNamedColors.table[lower] {
+            return fromARGB(named)
+        }
+        if let hex = parseHex(text), text.count == 6 || text.count == 8 {
+            return hex
+        }
+        return nil
+    }
+
+    /// Components (0...1) of `color` in the sRGB space.
+    public static func components(_ color: UIColor) -> (r: CGFloat, g: CGFloat, b: CGFloat, a: CGFloat) {
+        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        if color.getRed(&r, green: &g, blue: &b, alpha: &a) {
+            return (r, g, b, a)
+        }
+        var white: CGFloat = 0
+        if color.getWhite(&white, alpha: &a) {
+            return (white, white, white, a)
+        }
+        return (0, 0, 0, 1)
+    }
+
+    /// `#AARRGGBB` string for `color`, matching the Python interpolation output.
+    public static func hexString(_ color: UIColor) -> String {
+        let c = components(color)
+        func byte(_ v: CGFloat) -> Int { Int((max(0, min(1, v)) * 255).rounded()) }
+        return String(format: "#%02X%02X%02X%02X", byte(c.a), byte(c.r), byte(c.g), byte(c.b))
+    }
+
+    /// Build a color from a 32-bit ARGB integer (signed or unsigned).
+    public static func fromARGB(_ value: Int64) -> UIColor {
+        var argb = value
+        if argb < 0 { argb += 0x1_0000_0000 }
+        let a = CGFloat((argb >> 24) & 0xFF) / 255
+        let r = CGFloat((argb >> 16) & 0xFF) / 255
+        let g = CGFloat((argb >> 8) & 0xFF) / 255
+        let b = CGFloat(argb & 0xFF) / 255
+        return UIColor(red: r, green: g, blue: b, alpha: a)
+    }
+
+    // MARK: - Private
+
+    private static func parseHex(_ digits: String) -> UIColor? {
+        var hex = digits
+        switch hex.count {
+        case 3:
+            hex = "FF" + hex.map { "\($0)\($0)" }.joined()
+        case 4:
+            // #RGBA short form (CSS): expand then move alpha to the front.
+            let expanded = hex.map { "\($0)\($0)" }
+            hex = expanded[3] + expanded[0] + expanded[1] + expanded[2]
+        case 6:
+            hex = "FF" + hex
+        case 8:
+            break
+        default:
+            return nil
+        }
+        guard let value = Int64(hex, radix: 16) else { return nil }
+        return fromARGB(value)
+    }
+
+    private static func parseRGBFunction(_ text: String) -> UIColor? {
+        guard let open = text.firstIndex(of: "("), let close = text.lastIndex(of: ")"), open < close else { return nil }
+        let inner = text[text.index(after: open)..<close]
+        let parts = inner.split(whereSeparator: { $0 == "," || $0 == " " || $0 == "/" })
+            .map { $0.trimmingCharacters(in: .whitespaces) }
+            .filter { !$0.isEmpty }
+        guard parts.count == 3 || parts.count == 4 else { return nil }
+        func channel(_ s: String) -> CGFloat? {
+            if s.hasSuffix("%"), let v = Double(s.dropLast()) { return CGFloat(v / 100) }
+            guard let v = Double(s) else { return nil }
+            return CGFloat(v / 255)
+        }
+        func alpha(_ s: String) -> CGFloat? {
+            if s.hasSuffix("%"), let v = Double(s.dropLast()) { return CGFloat(v / 100) }
+            guard let v = Double(s) else { return nil }
+            return CGFloat(v)
+        }
+        guard let r = channel(parts[0]), let g = channel(parts[1]), let b = channel(parts[2]) else { return nil }
+        let a = parts.count == 4 ? (alpha(parts[3]) ?? 1) : 1
+        return UIColor(red: clamp(r), green: clamp(g), blue: clamp(b), alpha: clamp(a))
+    }
+
+    private static func dynamic(_ dict: [String: Any]) -> UIColor? {
+        let light = parse(dict["light"] ?? dict["default"])
+        let dark = parse(dict["dark"])
+        guard light != nil || dark != nil else { return nil }
+        return UIColor { traits in
+            if traits.userInterfaceStyle == .dark {
+                return dark ?? light ?? .clear
+            }
+            return light ?? dark ?? .clear
+        }
+    }
+
+    private static func clamp(_ v: CGFloat) -> CGFloat { max(0, min(1, v)) }
+}
+
+/// CSS named colors as ARGB integers.
+enum PNNamedColors {
+    static let table: [String: Int64] = [
+        "black": 0xFF00_0000, "white": 0xFFFF_FFFF, "red": 0xFFFF_0000, "green": 0xFF00_8000,
+        "blue": 0xFF00_00FF, "yellow": 0xFFFF_FF00, "cyan": 0xFF00_FFFF, "aqua": 0xFF00_FFFF,
+        "magenta": 0xFFFF_00FF, "fuchsia": 0xFFFF_00FF, "gray": 0xFF80_8080, "grey": 0xFF80_8080,
+        "silver": 0xFFC0_C0C0, "maroon": 0xFF80_0000, "olive": 0xFF80_8000, "lime": 0xFF00_FF00,
+        "teal": 0xFF00_8080, "navy": 0xFF00_0080, "purple": 0xFF80_0080, "orange": 0xFFFF_A500,
+        "pink": 0xFFFF_C0CB, "brown": 0xFFA5_2A2A, "gold": 0xFFFF_D700, "indigo": 0xFF4B_0082,
+        "violet": 0xFFEE_82EE, "tomato": 0xFFFF_6347, "coral": 0xFFFF_7F50, "salmon": 0xFFFA_8072,
+        "crimson": 0xFFDC_143C, "khaki": 0xFFF0_E68C, "beige": 0xFFF5_F5DC, "ivory": 0xFFFF_FFF0,
+        "lavender": 0xFFE6_E6FA, "plum": 0xFFDD_A0DD, "orchid": 0xFFDA_70D6, "turquoise": 0xFF40_E0D0,
+        "tan": 0xFFD2_B48C, "chocolate": 0xFFD2_691E, "firebrick": 0xFFB2_2222, "darkred": 0xFF8B_0000,
+        "darkgreen": 0xFF00_6400, "darkblue": 0xFF00_008B, "darkgray": 0xFFA9_A9A9, "darkgrey": 0xFFA9_A9A9,
+        "dimgray": 0xFF69_6969, "dimgrey": 0xFF69_6969, "lightgray": 0xFFD3_D3D3, "lightgrey": 0xFFD3_D3D3,
+        "lightblue": 0xFFAD_D8E6, "lightgreen": 0xFF90_EE90, "lightyellow": 0xFFFF_FFE0, "lightpink": 0xFFFF_B6C1,
+        "skyblue": 0xFF87_CEEB, "steelblue": 0xFF46_82B4, "royalblue": 0xFF41_69E1, "dodgerblue": 0xFF1E_90FF,
+        "deepskyblue": 0xFF00_BFFF, "slategray": 0xFF70_8090, "slategrey": 0xFF70_8090, "whitesmoke": 0xFFF5_F5F5,
+        "gainsboro": 0xFFDC_DCDC, "snow": 0xFFFF_FAFA, "seagreen": 0xFF2E_8B57, "forestgreen": 0xFF22_8B22,
+        "limegreen": 0xFF32_CD32, "springgreen": 0xFF00_FF7F, "mintcream": 0xFFF5_FFFA, "aquamarine": 0xFF7F_FFD4,
+        "hotpink": 0xFFFF_69B4, "deeppink": 0xFFFF_1493, "orangered": 0xFFFF_4500, "darkorange": 0xFFFF_8C00,
+        "goldenrod": 0xFFDA_A520, "sienna": 0xFFA0_522D, "peru": 0xFFCD_853F, "wheat": 0xFFF5_DEB3,
+        "linen": 0xFFFA_F0E6, "azure": 0xFFF0_FFFF, "honeydew": 0xFFF0_FFF0, "midnightblue": 0xFF19_1970,
+        "rebeccapurple": 0xFF66_3399, "mediumpurple": 0xFF93_70DB, "slateblue": 0xFF6A_5ACD, "cadetblue": 0xFF5F_9EA0,
+        "cornflowerblue": 0xFF64_95ED, "darkcyan": 0xFF00_8B8B, "darkmagenta": 0xFF8B_008B, "darkviolet": 0xFF94_00D3,
+        "darkslategray": 0xFF2F_4F4F, "darkslategrey": 0xFF2F_4F4F, "lightcoral": 0xFFF0_8080, "lightsalmon": 0xFFFF_A07A,
+        "lightseagreen": 0xFF20_B2AA, "lightskyblue": 0xFF87_CEFA, "lightslategray": 0xFF77_8899, "lightslategrey": 0xFF77_8899,
+        "lightsteelblue": 0xFFB0_C4DE, "mediumblue": 0xFF00_00CD, "mediumseagreen": 0xFF3C_B371, "mediumvioletred": 0xFFC7_1585,
+        "olivedrab": 0xFF6B_8E23, "palegreen": 0xFF98_FB98, "paleturquoise": 0xFFAF_EEEE, "palevioletred": 0xFFDB_7093,
+        "powderblue": 0xFFB0_E0E6, "rosybrown": 0xFFBC_8F8F, "saddlebrown": 0xFF8B_4513, "sandybrown": 0xFFF4_A460,
+        "thistle": 0xFFD8_BFD8, "yellowgreen": 0xFF9A_CD32, "chartreuse": 0xFF7F_FF00, "greenyellow": 0xFFAD_FF2F,
+    ]
+}