@swiftbrowser/native 0.10.4 → 0.12.0

package/swift/Sources/SwiftBrowserNative/Views/Kinds/Navigation.swift

@@ -15,10 +15,19 @@ struct NavigationStackElement: View {
     @Environment(\.nativeApp) private var app
 
     var body: some View {
-        let screens = node.children.filter { $0.kind == "navscreen" }
+        Self.stack(for: node, app: app)
+    }
+
+    /// The stack itself, with its root screen and the pushed ones as its
+    /// path. A split view's detail column is one of these directly (not a
+    /// view around one): the shim wraps a detail that is not a
+    /// `NavigationStack` in a stack of its own, and a stack nested in a
+    /// stack is flattened, its path with it.
+    static func stack(for node: ElementNode?, app: NativeApp?) -> NavigationStack<[Int], AnyView> {
+        let screens = node?.children.filter { $0.kind == "navscreen" } ?? []
         let pushed = screens.dropFirst().map(\.id)
         let path = Binding<[Int]>(
-            get: { node.children.filter { $0.kind == "navscreen" }.dropFirst().map(\.id) },
+            get: { node?.children.filter { $0.kind == "navscreen" }.dropFirst().map(\.id) ?? [] },
             set: { next in
                 // Only pops come from here (pushes come from the app).
                 for id in pushed where !next.contains(id) {
@@ -26,21 +35,69 @@ struct NavigationStackElement: View {
                 }
             }
         )
-        NavigationStack(path: path) {
-            Group {
-                if let root = screens.first {
-                    NavigationScreenElement(node: root)
+        return NavigationStack(path: path) {
+            AnyView(
+                Group {
+                    if let root = screens.first {
+                        NavigationScreenElement(node: root)
+                    }
                 }
-            }
-            .navigationDestination(for: Int.self) { id in
-                if let screen = node.children.first(where: { $0.id == id }) {
-                    NavigationScreenElement(node: screen)
-                } else {
-                    // Popped by the app already; SwiftUI is on its way out.
-                    Color.clear
+                .navigationDestination(for: Int.self) { id in
+                    if let screen = node?.children.first(where: { $0.id == id }) {
+                        NavigationScreenElement(node: screen)
+                    } else {
+                        // Popped by the app already; SwiftUI is on its way out.
+                        Color.clear
+                    }
+                }
+            )
+        }
+    }
+}
+
+/// `navsplit`: the sidebar's and the detail's stacks (its two `navstack`
+/// children, in that order) as the columns of a split view. The app emits
+/// it in a regular width only; in a compact width it emits one stack rooted
+/// at the sidebar, as iOS shows. `sidebarVisible` is the column visibility
+/// (`detailOnly` hides the sidebar); the sidebar toggle sends `tap` with the
+/// split's id, and the app flips the visibility, as the protocol says.
+struct NavigationSplitElement: View {
+    let node: ElementNode
+    @Environment(\.nativeApp) private var app
+
+    var body: some View {
+        let columns = node.children.filter { $0.kind == "navstack" }
+        let sidebar = columns.first
+        let detail = columns.count > 1 ? columns[1] : nil
+        let visibility = Binding<NavigationSplitViewVisibility>(
+            get: { NavSplitProps(props: node.props).sidebarVisible ? .all : .detailOnly },
+            set: { next in
+                if (next == .detailOnly) == NavSplitProps(props: node.props).sidebarVisible {
+                    app?.dispatch(.tap(node.id))
                 }
             }
+        )
+        NavigationSplitView(columnVisibility: visibility) {
+            sidebarColumn(sidebar)
+        } detail: {
+            NavigationStackElement.stack(for: detail, app: app)
+        }
+    }
+
+    /// The sidebar column: natively its stack (the column pushes within
+    /// itself); against the shim its root screen alone, since the shim gives
+    /// the sidebar a stack of its own and would flatten this one into it.
+    @ViewBuilder
+    private func sidebarColumn(_ sidebar: ElementNode?) -> some View {
+        #if canImport(FoundationBridge)
+        if let root = sidebar?.children.first(where: { $0.kind == "navscreen" }) {
+            NavigationScreenElement(node: root)
         }
+        #else
+        if let sidebar {
+            NavigationStackElement(node: sidebar)
+        }
+        #endif
     }
 }
 
@@ -98,7 +155,14 @@ struct NavigationScreenElement: View {
         case "principal": return .principal
         case "secondary": return .secondaryAction
         case "bottom": return bottomPlacement
-        default: return trailingPlacement // `trailing`, and `largeTitle` beside it
+        case "largeTitle":
+            // Beside the large title: the shim's own placement; SwiftUI has none, so the bar's trailing edge.
+            #if canImport(FoundationBridge)
+            return .largeTitle
+            #else
+            return trailingPlacement
+            #endif
+        default: return trailingPlacement
         }
     }
 }

package/swift/Sources/SwiftBrowserNative/Views/Kinds/Stacks.swift

@@ -11,6 +11,7 @@ struct VStackElement: View {
         VStack(alignment: HorizontalAlignment(name: props.alignment), spacing: props.spacing.map { CGFloat($0) }) {
             ChildrenView(node: node)
         }
+        .scrollTargetLayout(isEnabled: props.scrollTarget)
     }
 }
 
@@ -32,6 +33,7 @@ struct HStackElement: View {
             HStack(alignment: VerticalAlignment(name: props.alignment), spacing: props.spacing.map { CGFloat($0) }) {
                 ChildrenView(node: node)
             }
+            .scrollTargetLayout(isEnabled: props.scrollTarget)
         }
     }
 }
@@ -106,21 +108,71 @@ struct GeometryElement: View {
     }
 }
 
+/// `scrollview`: its axes and indicators; `refreshable` sends `refresh`;
+/// `snap` is its scroll target behavior (the stack inside marked
+/// `scrollTarget` is the layout whose children snap); `reportsPosition`
+/// is `.scrollPosition(id:)`, which sends `scrollposition` with the marked
+/// element at the anchor once the view settles. A `ScrollViewReader`'s
+/// `proxy.scrollTo(x)` arrives as a `scrollTo` hint, with a new serial each
+/// time, on the marked element it names (`scrollID`, `.id(x)`): the view
+/// finds the latest in its content and scrolls to it.
 struct ScrollViewElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
+    @State private var position: Int?
+    @State private var served: Double = -1
 
     var body: some View {
         let props = ScrollViewProps(props: node.props)
         let axes: Axis.Set = props.axes == "horizontal" ? .horizontal : props.axes == "both" ? [.horizontal, .vertical] : .vertical
-        let scroll = ScrollView(axes, showsIndicators: props.showsIndicators) {
-            ChildrenView(node: node)
+        let request = Self.scrollRequest(in: node)
+        ScrollViewReader { proxy in
+            let scroll = ScrollView(axes, showsIndicators: props.showsIndicators) {
+                ChildrenView(node: node)
+            }
+            let refreshed: AnyView = props.refreshable ? AnyView(scroll.refreshable { app?.dispatch(.refresh(node.id)) }) : AnyView(scroll)
+            let snapped: AnyView = props.snap == "paging" ? AnyView(refreshed.scrollTargetBehavior(.paging))
+                : props.snap == "viewAligned" ? AnyView(refreshed.scrollTargetBehavior(.viewAligned)) : refreshed
+            let positioned: AnyView = props.reportsPosition
+                ? AnyView(snapped.scrollPosition(id: Binding(get: { position }, set: { next in
+                    guard next != position else { return }
+                    position = next
+                    if let next { app?.dispatch(.scrollPosition(next)) }
+                }), anchor: props.positionAnchor.map(UnitPoint.init(spec:))))
+                : snapped
+            positioned
+                .onAppear { perform(request, with: proxy) }
+                .onChange(of: request?.serial) { _, _ in perform(request, with: proxy) }
         }
-        if props.refreshable {
-            scroll.refreshable { app?.dispatch(.refresh(node.id)) }
-        } else {
-            scroll
+    }
+
+    private func perform(_ request: ScrollRequest?, with proxy: ScrollViewProxy) {
+        guard let request, request.serial > served else { return }
+        served = request.serial
+        position = request.id
+        proxy.scrollTo(request.id, anchor: request.anchor)
+    }
+
+    struct ScrollRequest: Equatable {
+        var serial: Double
+        var id: Int
+        var anchor: UnitPoint?
+    }
+
+    /// The newest `scrollTo` among the content's marked elements (not those of a scroll view nested inside).
+    static func scrollRequest(in node: ElementNode) -> ScrollRequest? {
+        var best: ScrollRequest?
+        func visit(_ element: ElementNode) {
+            for child in element.children {
+                if child.kind == "scrollview" || child.kind == "list" { continue }
+                if child.kind == "styled", let request = child.style.scrollTo, best == nil || request.serial > best!.serial {
+                    best = ScrollRequest(serial: request.serial, id: child.id, anchor: request.anchor.map(UnitPoint.init(spec:)))
+                }
+                visit(child)
+            }
         }
+        visit(node)
+        return best
     }
 }
 

package/swift/Sources/SwiftBrowserNative/Views/StyleModifier.swift

@@ -11,7 +11,7 @@ import SwiftUI
 /// Type-erased step by step: a chain of sixty optional modifiers would
 /// otherwise be one type the compiler has to name.
 extension View {
-    func styled(_ style: Style) -> AnyView {
+    func styled(_ style: Style, id: Int? = nil) -> AnyView {
         var view = AnyView(self)
 
         // Text attributes, which flow down the environment. A font with only a
@@ -71,16 +71,31 @@ extension View {
             }
         }
         if let frame = style.frame {
-            if frame.isFlexible {
+            // Per axis, a fixed length wins over a min/max, as the web renderer
+            // lays it out: `{ maxWidth: "infinity", height: 1 }` is
+            // `.frame(height: 1).frame(maxWidth: .infinity)`, a rule across
+            // the width.
+            let alignment = Alignment(name: frame.alignment)
+            if frame.width != nil || frame.height != nil {
+                view = AnyView(view.frame(width: frame.width.map { CGFloat($0) }, height: frame.height.map { CGFloat($0) }, alignment: alignment))
+            }
+            let flexibleWidth = frame.width == nil && (frame.minWidth != nil || frame.maxWidth != nil)
+            let flexibleHeight = frame.height == nil && (frame.minHeight != nil || frame.maxHeight != nil)
+            if flexibleWidth || flexibleHeight {
                 view = AnyView(view.frame(
-                    minWidth: CGFloat(dimension: frame.minWidth), maxWidth: CGFloat(dimension: frame.maxWidth),
-                    minHeight: CGFloat(dimension: frame.minHeight), maxHeight: CGFloat(dimension: frame.maxHeight),
-                    alignment: Alignment(name: frame.alignment)
+                    minWidth: flexibleWidth ? CGFloat(dimension: frame.minWidth) : nil, maxWidth: flexibleWidth ? CGFloat(dimension: frame.maxWidth) : nil,
+                    minHeight: flexibleHeight ? CGFloat(dimension: frame.minHeight) : nil, maxHeight: flexibleHeight ? CGFloat(dimension: frame.maxHeight) : nil,
+                    alignment: alignment
                 ))
-            } else {
-                view = AnyView(view.frame(width: frame.width.map { CGFloat($0) }, height: frame.height.map { CGFloat($0) }, alignment: Alignment(name: frame.alignment)))
             }
         }
+        if let relative = style.containerRelativeFrame {
+            var axes: Axis.Set = []
+            if relative.horizontal { axes.insert(.horizontal) }
+            if relative.vertical { axes.insert(.vertical) }
+            let a = relative.a, b = relative.b
+            view = AnyView(view.containerRelativeFrame(axes, alignment: Alignment(name: relative.alignment)) { length, _ in a * length + b })
+        }
         if let ratio = style.aspectRatio {
             let mode: ContentMode = style.aspectRatioContentMode == "fill" ? .fill : .fit
             view = AnyView(view.aspectRatio(ratio.map { CGFloat($0) }, contentMode: mode))
@@ -127,6 +142,9 @@ extension View {
         if style.hitTesting == false { view = AnyView(view.allowsHitTesting(false)) }
         if style.hidden { view = AnyView(view.hidden()) }
         if let help = style.help { view = AnyView(view.help(help)) }
+        // A `ScrollViewReader`'s `.id(x)`: the element's own id names it to a `scrollTo` and a scroll position.
+        if style.scrollID, let id { view = AnyView(view.id(id)) }
+        if let width = style.raw.double("inspectorColumnWidth") { view = AnyView(view.inspectorColumnWidth(width)) }
 
         // Lists.
         if let badge = style.badge { view = AnyView(view.badge(Text(badge))) }

package/swift/Sources/SwiftBrowserProtocol/Props.swift

@@ -54,9 +54,13 @@ public struct StackProps: Equatable, Sendable {
     /// A `VStack`'s horizontal alignment, an `HStack`'s vertical one, a `ZStack`'s frame alignment.
     public var alignment: String
 
+    /// `.scrollTargetLayout()`: the stack's children are the snap points of the scroll view around it.
+    public var scrollTarget: Bool
+
     public init(props: JSONObject) {
         spacing = props.double("spacing")
         alignment = props.string("alignment") ?? "center"
+        scrollTarget = props.bool("scrollTarget") ?? false
     }
 }
 
@@ -111,13 +115,27 @@ public struct ScrollViewProps: Equatable, Sendable {
     public var axes: String
     public var showsIndicators: Bool
     public var refreshable: Bool
+    /// `.scrollTargetBehavior`: `viewAligned` or `paging`.
+    public var snap: String?
+    /// `.scrollPosition(id:)`: the view reports the marked element at its anchor as it settles.
+    public var reportsPosition: Bool
+    public var positionAnchor: UnitPointSpec?
     public init(props: JSONObject) {
         axes = props.string("axes") ?? "vertical"
         showsIndicators = props.bool("showsIndicators") ?? true
         refreshable = props.bool("refreshable") ?? false
+        snap = props.string("snap")
+        reportsPosition = props.bool("reportsPosition") ?? false
+        positionAnchor = UnitPointSpec(json: props.value("positionAnchor"))
     }
 }
 
+/// `inspector`: the modified view's elements, then an `inspectorpanel`.
+public struct InspectorProps: Equatable, Sendable {
+    public var presented: Bool
+    public init(props: JSONObject) { presented = props.bool("presented") ?? false }
+}
+
 public struct ListProps: Equatable, Sendable {
     /// `insetGrouped` (the default), `grouped`, `plain`, `sidebar`.
     public var style: String
@@ -183,6 +201,12 @@ public struct NavScreenProps: Equatable, Sendable {
     }
 }
 
+public struct NavSplitProps: Equatable, Sendable {
+    /// Whether the sidebar column shows (`false` hides it).
+    public var sidebarVisible: Bool
+    public init(props: JSONObject) { sidebarVisible = props.bool("sidebarVisible") ?? true }
+}
+
 public struct NavLinkProps: Equatable, Sendable {
     public var selected: Bool
     public var plain: Bool
@@ -467,3 +491,155 @@ public struct SizeReportProps: Equatable, Sendable {
         reader = props.int("reader")
     }
 }
+
+// MARK: - Charts
+
+/// `chart`: the marks in unit coordinates of the plot (x 0…1 left to right,
+/// y 0…1 top to bottom), the axes with their grid lines, ticks and labels
+/// already placed and formatted, and the legend (docs/ops-protocol.md,
+/// "Phase 7"). A renderer measures the labels, lays the plot out and draws.
+public struct ChartProps: Equatable, Sendable {
+    public var marks: [ChartMarkSpec]
+    public var xAxis: ChartAxisSpec?
+    public var yAxis: ChartAxisSpec?
+    public var legend: ChartLegendSpec?
+    public init(props: JSONObject) {
+        marks = (props.array("marks") ?? []).compactMap(ChartMarkSpec.init(json:))
+        xAxis = ChartAxisSpec(json: props.value("xAxis"))
+        yAxis = ChartAxisSpec(json: props.value("yAxis"))
+        legend = ChartLegendSpec(json: props.value("legend"))
+    }
+}
+
+/// A point of a line (`y`) or an area (`y0 ≤ y1`) mark.
+public struct ChartPointSpec: Equatable, Sendable {
+    public var x: Double
+    public var y: Double
+    public var y0: Double
+    public var y1: Double
+    init?(json: JSONValue) {
+        guard let x = json["x"].double else { return nil }
+        self.x = x
+        y = json["y"].double ?? json["y0"].double ?? 0
+        y0 = json["y0"].double ?? y
+        y1 = json["y1"].double ?? y
+    }
+}
+
+/// One mark: `rect` (bars), `line`, `area`, `point` or `rule`.
+public struct ChartMarkSpec: Equatable, Sendable {
+    public var kind: String
+    public var style: ShapeStyleSpec?
+    public var opacity: Double
+    /// `rect` and `rule`: the unit rect (a rule's two ends); `point`: `x0`/`y0`.
+    public var x0: Double
+    public var x1: Double
+    public var y0: Double
+    public var y1: Double
+    public var cornerRadius: Double
+    /// A rect this wide in points, centered on the unit rect, instead of the unit rect's width.
+    public var fixedWidth: Double?
+    /// `line` and `area`.
+    public var points: [ChartPointSpec]
+    public var lineWidth: Double
+    public var interpolation: String
+    /// `circle`, `square`, `triangle`, `diamond`, `cross`, `plus`, `asterisk`; nil for none.
+    public var symbol: String?
+    public var symbolSize: Double
+    public init?(json: JSONValue) {
+        guard let kind = json["kind"].string else { return nil }
+        self.kind = kind
+        style = ShapeStyleSpec(json: json["style"])
+        opacity = json["opacity"].double ?? 1
+        x0 = json["x0"].double ?? json["x"].double ?? 0
+        x1 = json["x1"].double ?? x0
+        y0 = json["y0"].double ?? json["y"].double ?? 0
+        y1 = json["y1"].double ?? y0
+        cornerRadius = json["cornerRadius"].double ?? 0
+        fixedWidth = json["fixedWidth"].double
+        points = (json["points"].array ?? []).compactMap(ChartPointSpec.init(json:))
+        lineWidth = json["lineWidth"].double ?? (kind == "rule" ? 1 : 2)
+        interpolation = json["interpolation"].string ?? "linear"
+        symbol = json["symbol"].string ?? (kind == "point" ? "circle" : nil)
+        symbolSize = json["symbolSize"].double ?? 8
+    }
+}
+
+public struct ChartAxisLabelSpec: Equatable, Sendable {
+    /// Unit position along the axis (y: 0 is the top).
+    public var at: Double
+    public var text: String
+    /// `leading`: an x label that starts at its tick instead of centering on it.
+    public var anchor: String?
+    init?(json: JSONValue) {
+        guard let at = json["at"].double else { return nil }
+        self.at = at
+        text = json["text"].string ?? ""
+        anchor = json["anchor"].string
+    }
+}
+
+public struct ChartAxisSpec: Equatable, Sendable {
+    /// x: `bottom` or `top`; y: `trailing` or `leading`.
+    public var position: String
+    public var gridLines: [Double]
+    public var dashed: Bool
+    public var ticks: [Double]
+    public var labels: [ChartAxisLabelSpec]
+    public init?(json: JSONValue) {
+        guard let fields = json.object else { return nil }
+        position = fields.string("position") ?? "bottom"
+        gridLines = (fields.array("gridLines") ?? []).compactMap(\.double)
+        dashed = fields.bool("dashed") ?? false
+        ticks = (fields.array("ticks") ?? []).compactMap(\.double)
+        labels = (fields.array("labels") ?? []).compactMap(ChartAxisLabelSpec.init(json:))
+    }
+}
+
+public struct ChartLegendItemSpec: Equatable, Sendable {
+    public var label: String
+    public var style: ShapeStyleSpec?
+    /// Nil: a short line instead of a symbol.
+    public var symbol: String?
+    init(json: JSONValue) {
+        label = json["label"].string ?? ""
+        style = ShapeStyleSpec(json: json["style"])
+        symbol = json["symbol"].string
+    }
+}
+
+public struct ChartLegendSpec: Equatable, Sendable {
+    /// `top`, `bottom`, `leading` or `trailing`.
+    public var position: String
+    public var items: [ChartLegendItemSpec]
+    public init?(json: JSONValue) {
+        guard let fields = json.object else { return nil }
+        position = fields.string("position") ?? "bottom"
+        items = (fields.array("items") ?? []).map(ChartLegendItemSpec.init(json:))
+    }
+}
+
+/// `chartitem`: an annotation against its mark's unit rect, or an axis label
+/// view at its tick (`x0 == x1` for an x label, `y0 == y1` for a y label).
+public struct ChartItemProps: Equatable, Sendable {
+    /// `annotation`, `xLabel` or `yLabel`.
+    public var role: String
+    public var x0: Double
+    public var x1: Double
+    public var y0: Double
+    public var y1: Double
+    /// `top`, `bottom`, `leading`, `trailing` or `overlay`.
+    public var position: String
+    public var alignment: String
+    public var spacing: Double
+    public init(props: JSONObject) {
+        role = props.string("role") ?? "annotation"
+        x0 = props.double("x0") ?? 0
+        x1 = props.double("x1") ?? x0
+        y0 = props.double("y0") ?? 0
+        y1 = props.double("y1") ?? y0
+        position = props.string("position") ?? "overlay"
+        alignment = props.string("alignment") ?? "center"
+        spacing = props.double("spacing") ?? 0
+    }
+}

package/swift/Sources/SwiftBrowserProtocol/RendererEvent.swift

@@ -88,6 +88,8 @@ public struct RendererEvent: Equatable, Sendable {
     public static func longPress(_ id: Int) -> RendererEvent { with("longpress", id: id) }
     /// A `list` or `scrollview` with `refreshable` was pulled.
     public static func refresh(_ id: Int) -> RendererEvent { with("refresh", id: id) }
+    /// `.scrollPosition(id:)`: the marked element at the scroll view's anchor once it settled.
+    public static func scrollPosition(_ id: Int) -> RendererEvent { with("scrollposition", id: id) }
     /// A `menu` opened or closed (lazy menus build their items on `open`).
     public static func menu(_ id: Int, open: Bool) -> RendererEvent { with("menu", id: id, ["open": .bool(open)]) }
     /// The host's answer to a `native` element's own event (docs/native.md, the escape hatch).

package/swift/Sources/SwiftBrowserProtocol/Style.swift

@@ -67,6 +67,12 @@ public struct Style: Equatable, Sendable {
     public var help: String?
     public var matchedGeometry: String?
     public var contentTransition: String?
+    /// `.containerRelativeFrame`: the length along each named axis is `a × container + b`.
+    public var containerRelativeFrame: ContainerRelativeFrameSpec?
+    /// `.id(x)` inside a `ScrollViewReader`: the element a `scrollTo` or a scroll position names.
+    public var scrollID: Bool
+    /// `proxy.scrollTo(x)`: the request (its serial is new each time) on the element it names.
+    public var scrollTo: ScrollToSpec?
 
     public init(json: JSONValue) {
         let fields = json.object ?? [:]
@@ -137,6 +143,9 @@ public struct Style: Equatable, Sendable {
         help = fields.string("help")
         matchedGeometry = fields.string("matchedGeometry")
         contentTransition = fields.object("contentTransition")?.string("kind")
+        containerRelativeFrame = ContainerRelativeFrameSpec(json: fields.value("containerRelativeFrame"))
+        scrollID = fields.bool("scrollID") ?? false
+        scrollTo = ScrollToSpec(json: fields.value("scrollTo"))
     }
 
     public init() {
@@ -146,3 +155,35 @@ public struct Style: Equatable, Sendable {
     /// The style's field names, for the unsupported-field diagnostics and tests.
     public var fieldNames: [String] { raw.keys.sorted() }
 }
+
+/// `.containerRelativeFrame(axes)` as the style hint carries it: `length = a × container + b`.
+public struct ContainerRelativeFrameSpec: Equatable, Sendable {
+    public var horizontal: Bool
+    public var vertical: Bool
+    public var a: Double
+    public var b: Double
+    public var alignment: String
+    public init?(json: JSONValue) {
+        guard let fields = json.object else { return nil }
+        horizontal = fields.bool("horizontal") ?? false
+        vertical = fields.bool("vertical") ?? false
+        a = fields.double("a") ?? 1
+        b = fields.double("b") ?? 0
+        alignment = fields.string("alignment") ?? "center"
+    }
+}
+
+/// A `ScrollViewReader` proxy's `scrollTo` on the element it names.
+public struct ScrollToSpec: Equatable, Sendable {
+    /// Increases with every request, across all readers.
+    public var serial: Double
+    public var anchor: UnitPointSpec?
+    /// `horizontal`, `vertical` or `both` (the default).
+    public var axes: String
+    public init?(json: JSONValue) {
+        guard let fields = json.object, let serial = fields.double("serial") else { return nil }
+        self.serial = serial
+        anchor = UnitPointSpec(json: fields.value("anchor"))
+        axes = fields.string("axes") ?? "both"
+    }
+}

package/wasm/SwiftBrowserNative.wasm

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/wasm/SwiftBrowserNative.wasm
+size: 49299172 bytes
+sha256: 4b0ae4bc428d21234784a4c806f021482aa294045f94c5fc80eeea0ad40b5405