library;

import 'dart:core';

import 'dart:math' as math;

import 'dart:ui'

show

CheckedState,

Locale,

Offset,

Rect,

SemanticsAction,

SemanticsFlag,

SemanticsFlags,

SemanticsInputType,

SemanticsRole,

SemanticsUpdate,

SemanticsUpdateBuilder,

SemanticsValidationResult,

StringAttribute,

TextDirection,

Tristate;

import 'dart:ui' as ui show SemanticsHitTestBehavior;

import 'package:collection/collection.dart';

import 'package:flutter/foundation.dart';

import 'package:flutter/painting.dart' show MatrixUtils, TransformProperty;

import 'package:flutter/services.dart';

import 'package:vector_math/vector_math_64.dart';

import 'binding.dart' show SemanticsBinding;

import 'semantics_event.dart';

export 'dart:ui'

show

Offset,

Rect,

SemanticsAction,

SemanticsFlag,

SemanticsFlags,

SemanticsRole,

SemanticsValidationResult,

StringAttribute,

TextDirection,

VoidCallback;

export 'package:flutter/foundation.dart'

show

DiagnosticLevel,

DiagnosticPropertiesBuilder,

DiagnosticsNode,

DiagnosticsTreeStyle,

Key,

TextTreeConfiguration;

export 'package:flutter/services.dart' show TextSelection;

export 'package:vector_math/vector_math_64.dart' show Matrix4;

export 'semantics_event.dart' show SemanticsEvent;

typedef SemanticsNodeVisitor = bool Function(SemanticsNode node);

typedef MoveCursorHandler = void Function(bool extendSelection);

typedef SetSelectionHandler = void Function(TextSelection selection);

typedef SetTextHandler = void Function(String text);

typedef ScrollToOffsetHandler = void Function(Offset targetOffset);

typedef SemanticsActionHandler = void Function(Object? args);

typedef SemanticsUpdateCallback = void Function(SemanticsUpdate update);

typedef ChildSemanticsConfigurationsDelegate = ChildSemanticsConfigurationsResult Function(

List<SemanticsConfiguration>,

);

enum AccessibilityFocusBlockType {

/// Accessibility focus is **not blocked**.

none,

/// Blocks accessibility focus for the entire subtree.

blockSubtree,

/// Blocks accessibility focus for the **current node only**. Its descendants

blockNode;

/// The AccessibilityFocusBlockType when two nodes get merged.

AccessibilityFocusBlockType _merge(AccessibilityFocusBlockType other) {

// 1. If either is blockSubtree, the result is blockSubtree.

if (this == AccessibilityFocusBlockType.blockSubtree ||

other == AccessibilityFocusBlockType.blockSubtree) {

return AccessibilityFocusBlockType.blockSubtree;

}

// 2. If either is blockNode, the result is blockNode

if (this == AccessibilityFocusBlockType.blockNode ||

other == AccessibilityFocusBlockType.blockNode) {

return AccessibilityFocusBlockType.blockNode;

}

// 3. If neither is blockSubtree nor blockNode, both must be none.

return AccessibilityFocusBlockType.none;

}

}

final int _kUnblockedUserActions =

SemanticsAction.didGainAccessibilityFocus.index |

SemanticsAction.didLoseAccessibilityFocus.index;

sealed class _DebugSemanticsRoleChecks {

static FlutterError? _checkSemanticsData(SemanticsNode node) {

final FlutterError? error = switch (node.role) {

SemanticsRole.alertDialog => _noCheckRequired,

SemanticsRole.dialog => _noCheckRequired,

SemanticsRole.none => _noCheckRequired,

SemanticsRole.tab => _semanticsTab,

SemanticsRole.tabBar => _semanticsTabBar,

SemanticsRole.tabPanel => _noCheckRequired,

SemanticsRole.table => _semanticsTable,

SemanticsRole.cell => _semanticsCell,

SemanticsRole.row => _semanticsRow,

SemanticsRole.columnHeader => _semanticsColumnHeader,

SemanticsRole.radioGroup => _semanticsRadioGroup,

SemanticsRole.menu => _semanticsMenu,

SemanticsRole.menuBar => _semanticsMenuBar,

SemanticsRole.menuItem => _semanticsMenuItem,

SemanticsRole.menuItemCheckbox => _semanticsMenuItemCheckbox,

SemanticsRole.menuItemRadio => _semanticsMenuItemRadio,

SemanticsRole.alert => _noLiveRegion,

SemanticsRole.status => _noLiveRegion,

SemanticsRole.list => _noCheckRequired,

SemanticsRole.listItem => _semanticsListItem,

SemanticsRole.complementary => _semanticsComplementary,

SemanticsRole.contentInfo => _semanticsContentInfo,

SemanticsRole.main => _semanticsMain,

SemanticsRole.navigation => _semanticsNavigation,

SemanticsRole.region => _semanticsRegion,

SemanticsRole.form => _noCheckRequired,

SemanticsRole.loadingSpinner => _noCheckRequired,

SemanticsRole.progressBar => _semanticsProgressBar,

SemanticsRole.slider => _semanticsSlider,

// TODO(chunhtai): add checks when the roles are used in framework.

// https://github.com/flutter/flutter/issues/159741.

SemanticsRole.dragHandle => _unimplemented,

SemanticsRole.spinButton => _unimplemented,

SemanticsRole.comboBox => _unimplemented,

SemanticsRole.tooltip => _unimplemented,

SemanticsRole.hotKey => _unimplemented,

}(node);

if (error != null) {

return error;

}

return _semanticsGeneral(node);

}

static FlutterError? _unimplemented(SemanticsNode node) =>

FlutterError('Missing checks for role ${node.getSemanticsData().role}');

static FlutterError? _noCheckRequired(SemanticsNode node) => null;

static FlutterError? _semanticsProgressBar(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

// Check if value is present

if (data.value.isEmpty ||

(data.minValue?.isEmpty ?? true) ||

(data.maxValue?.isEmpty ?? true)) {

return FlutterError('A progress bar must have a value, a minValue, a maxValue.');

}

final double? minVal = double.tryParse(data.minValue!);

final double? maxVal = double.tryParse(data.maxValue!);

// The value can either be a direct number fall within the min and max range

// or a percentage number between 0% and 100%

final double? currentValue = double.tryParse(data.value);

final double? percentValue = data.value.endsWith('%')

? double.tryParse(data.value.substring(0, data.value.length - 1))

: null;

if (minVal == null || maxVal == null || (currentValue == null && percentValue == null)) {

return FlutterError(

'Progress bar value, minValue, and maxValue must be valid numbers. '

'value: "${data.value}", minValue: "${data.minValue}", maxValue: "${data.maxValue}"',

);

}

// Validate min/max relation since both are guaranteed to be valid numbers.

if (minVal >= maxVal) {

return FlutterError(

'Progress bar minValue (${data.minValue}) must be less than maxValue (${data.maxValue})',

);

}

// If the value is a number, it must be between min and max.

if (currentValue != null) {

if (currentValue < minVal || currentValue > maxVal) {

return FlutterError(

'Progress bar value (${data.value}) must be between minValue (${data.minValue}) and maxValue (${data.maxValue})',

);

}

return null;

}

// If the value is a percentage string (e.g., "50%"), it must be between 0% and 100%.

if (percentValue != null && (percentValue < 0 || percentValue > 100)) {

return FlutterError(

'Progress bar percentage value (${data.value}) must be between 0% and 100%',

);

}

return null;

}

static FlutterError? _semanticsSlider(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

// Check if value is present

if (data.value.isEmpty) {

return FlutterError('A slider must have a value');

}

// Check if minValue and maxValue are present

if (data.minValue?.isEmpty ?? true) {

return FlutterError('A slider must have a minValue');

}

if (data.maxValue?.isEmpty ?? true) {

return FlutterError('A slider must have a maxValue');

}

// Validate that value is within min and max range

try {

final double currentValue = double.parse(data.value.replaceAll('%', ''));

final double minVal = double.parse(data.minValue!);

final double maxVal = double.parse(data.maxValue!);

if (minVal >= maxVal) {

return FlutterError(

'Slider minValue (${data.minValue}) must be less than maxValue (${data.maxValue})',

);

}

if (data.value.contains('%')) {

if (currentValue < 0.0 || currentValue > 100.0) {

return FlutterError(

'Slider percentage value (${data.value}) must be between 0% and 100%',

);

}

} else {

if (currentValue < minVal || currentValue > maxVal) {

return FlutterError(

'Slider value (${data.value}) must be between minValue (${data.minValue}) and maxValue (${data.maxValue})',

);

}

}

} on FormatException {

return FlutterError(

'Slider value, minValue, and maxValue must be valid numbers. '

'value: "${data.value}", minValue: "${data.minValue}", maxValue: "${data.maxValue}"',

);

}

return null;

}

static FlutterError? _semanticsTab(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

if (data.flagsCollection.isSelected == Tristate.none) {

return FlutterError('A tab needs selected states');

}

if (node.areUserActionsBlocked) {

return null;

}

if (data.flagsCollection.isEnabled != Tristate.isFalse &&

!data.hasAction(SemanticsAction.tap)) {

return FlutterError('A tab must have a tap action');

}

return null;

}

static FlutterError? _semanticsTabBar(SemanticsNode node) {

if (node.childrenCount < 1) {

return FlutterError('a TabBar cannot be empty');

}

FlutterError? error;

node.visitChildren((SemanticsNode child) {

if (child.getSemanticsData().role != SemanticsRole.tab) {

error = FlutterError('Children of TabBar must have the tab role');

}

return error == null;

});

return error;

}

static FlutterError? _semanticsTable(SemanticsNode node) {

FlutterError? error;

node.visitChildren((SemanticsNode child) {

if (child.getSemanticsData().role != SemanticsRole.row) {

error = FlutterError('Children of Table must have the row role');

}

return error == null;

});

return error;

}

static FlutterError? _semanticsRow(SemanticsNode node) {

if (node.parent?.role != SemanticsRole.table) {

return FlutterError('A row must be a child of a table');

}

FlutterError? error;

node.visitChildren((SemanticsNode child) {

if (child.getSemanticsData().role != SemanticsRole.cell &&

child.getSemanticsData().role != SemanticsRole.columnHeader) {

error = FlutterError('Children of Row must have the cell or columnHeader role');

}

return error == null;

});

return error;

}

static FlutterError? _semanticsCell(SemanticsNode node) {

if (node.parent?.role != SemanticsRole.row && node.parent?.role != SemanticsRole.cell) {

return FlutterError('A cell must be a child of a row or another cell');

}

return null;

}

static FlutterError? _semanticsColumnHeader(SemanticsNode node) {

if (node.parent?.role != SemanticsRole.row && node.parent?.role != SemanticsRole.cell) {

return FlutterError('A columnHeader must be a child or another cell');

}

return null;

}

static FlutterError? _semanticsRadioGroup(SemanticsNode node) {

FlutterError? error;

var hasCheckedChild = false;

bool validateRadioGroupChildren(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

if (data.role == SemanticsRole.radioGroup) {

// Children under sub radio groups don't belong to this radio group.

return error == null;

}

if (!data.flagsCollection.isInMutuallyExclusiveGroup) {

node.visitChildren(validateRadioGroupChildren);

return error == null;

}

if (data.flagsCollection.isChecked == CheckedState.isTrue) {

if (hasCheckedChild) {

error = FlutterError('Radio groups must not have multiple checked children');

return false;

}

hasCheckedChild = true;

}

assert(error == null);

return true;

}

node.visitChildren(validateRadioGroupChildren);

return error;

}

static FlutterError? _semanticsMenu(SemanticsNode node) {

if (node.childrenCount < 1) {

return FlutterError('a menu cannot be empty');

}

return null;

}

static FlutterError? _semanticsMenuBar(SemanticsNode node) {

if (node.childrenCount < 1) {

return FlutterError('a menu bar cannot be empty');

}

return null;

}

static FlutterError? _semanticsMenuItem(SemanticsNode node) {

SemanticsNode? currentNode = node;

while (currentNode?.parent != null) {

if (currentNode?.parent?.role == SemanticsRole.menu ||

currentNode?.parent?.role == SemanticsRole.menuBar) {

return null;

}

currentNode = currentNode?.parent;

}

return FlutterError('A menu item must be a child of a menu or a menu bar');

}

static FlutterError? _semanticsMenuItemCheckbox(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

if (data.flagsCollection.isChecked == CheckedState.none) {

return FlutterError('a menu item checkbox must be checkable');

}

SemanticsNode? currentNode = node;

while (currentNode?.parent != null) {

if (currentNode?.parent?.role == SemanticsRole.menu ||

currentNode?.parent?.role == SemanticsRole.menuBar) {

return null;

}

currentNode = currentNode?.parent;

}

return FlutterError('A menu item checkbox must be a child of a menu or a menu bar');

}

static FlutterError? _semanticsMenuItemRadio(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

if (data.flagsCollection.isChecked == CheckedState.none) {

return FlutterError('a menu item radio must be checkable');

}

SemanticsNode? currentNode = node;

while (currentNode?.parent != null) {

if (currentNode?.parent?.role == SemanticsRole.menu ||

currentNode?.parent?.role == SemanticsRole.menuBar) {

return null;

}

currentNode = currentNode?.parent;

}

return FlutterError('A menu item radio must be a child of a menu or a menu bar');

}

static FlutterError? _noLiveRegion(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

if (data.flagsCollection.isLiveRegion) {

return FlutterError(

'Node ${node.id} has role ${data.role} but is also a live region. '

'A node can not have ${data.role} and be live region at the same time. '

'Either remove the role or the live region',

);

}

return null;

}

static FlutterError? _semanticsListItem(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

final SemanticsNode? parent = node.parent;

if (parent == null) {

return FlutterError(

"Semantics node ${node.id} has role ${data.role} but doesn't have a parent",

);

}

final SemanticsData parentSemanticsData = parent.getSemanticsData();

if (parentSemanticsData.role != SemanticsRole.list) {

return FlutterError(

'Semantics node ${node.id} has role ${data.role}, but its '

"parent node ${parent.id} doesn't have the role ${SemanticsRole.list}. "

'Please assign the ${SemanticsRole.list} to node ${parent.id}',

);

}

return null;

}

static bool _isLandmarkRole(SemanticsData nodeData) =>

nodeData.role == SemanticsRole.complementary ||

nodeData.role == SemanticsRole.contentInfo ||

nodeData.role == SemanticsRole.main ||

nodeData.role == SemanticsRole.navigation ||

nodeData.role == SemanticsRole.region;

static bool _isSameRoleExisted(SemanticsNode semanticsNode) {

final Map<int, SemanticsNode> treeNodes = semanticsNode.owner!._nodes;

var sameRoleCount = 0;

for (final int id in treeNodes.keys) {

if (treeNodes[id]?.getSemanticsData().role == semanticsNode.role) {

sameRoleCount++;

if (sameRoleCount > 1) {

return true;

}

}

}

return false;

}

static FlutterError? _semanticsComplementary(SemanticsNode node) {

SemanticsNode? currentNode = node.parent;

while (currentNode != null) {

if (_isLandmarkRole(currentNode.getSemanticsData())) {

return FlutterError(

'The complementary landmark role should not contained within any other landmark roles.',

);

}

currentNode = currentNode.parent;

}

final SemanticsData data = node.getSemanticsData();

if (_isSameRoleExisted(node) && data.label.isEmpty) {

return FlutterError(

'The complementary landmark role should have a unique label as it is used more than once.',

);

}

return null;

}

static FlutterError? _semanticsContentInfo(SemanticsNode node) {

SemanticsNode? currentNode = node.parent;

while (currentNode != null) {

if (_isLandmarkRole(currentNode.getSemanticsData())) {

return FlutterError(

'The contentInfo landmark role should not contained within any other landmark roles.',

);

}

currentNode = currentNode.parent;

}

final SemanticsData data = node.getSemanticsData();

if (_isSameRoleExisted(node) && data.label.isEmpty) {

return FlutterError(

'The contentInfo landmark role should have a unique label as it is used more than once.',

);

}

return null;

}

static FlutterError? _semanticsMain(SemanticsNode node) {

SemanticsNode? currentNode = node.parent;

while (currentNode != null) {

if (_isLandmarkRole(currentNode.getSemanticsData())) {

return FlutterError(

'The main landmark role should not contained within any other landmark roles.',

);

}

currentNode = currentNode.parent;

}

final SemanticsData data = node.getSemanticsData();

if (_isSameRoleExisted(node) && data.label.isEmpty) {

return FlutterError(

'The main landmark role should have a unique label as it is used more than once.',

);

}

return null;

}

static FlutterError? _semanticsNavigation(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

if (_isSameRoleExisted(node) && data.label.isEmpty) {

return FlutterError(

'The navigation landmark role should have a unique label as it is used more than once.',

);

}

return null;

}

static FlutterError? _semanticsRegion(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

if (data.label.isEmpty) {

return FlutterError(

'A region role should include a label that describes the purpose of the content.',

);

}

return null;

}

static FlutterError? _semanticsGeneral(SemanticsNode node) {

final SemanticsData data = node.getSemanticsData();

final bool? isExpanded = data.flagsCollection.isExpanded.toBoolOrNull();

if (isExpanded != null) {

final bool hasExpandAction = data.hasAction(SemanticsAction.expand);

final bool hasCollapseAction = data.hasAction(SemanticsAction.collapse);

if (hasExpandAction && hasCollapseAction) {

return FlutterError(

'An expandable node cannot have both expand and collapse actions set at the same time.',

);

}

if (isExpanded && hasExpandAction) {

return FlutterError('An expanded node cannot have an expand action.');

}

if (!isExpanded && hasCollapseAction) {

return FlutterError('A collapsed node cannot have a collapse action.');

}

}

if (data.flagsCollection.isAccessibilityFocusBlocked &&

data.flagsCollection.isFocused != Tristate.none) {

return FlutterError(

'A node that is keyboard focusable cannot be set to accessibility unfocusable',

);

}

return null;

}

}

class SemanticsTag {

/// Creates a [SemanticsTag].

const SemanticsTag(this.name);

/// A human-readable name for this tag used for debugging.

final String name;

@override

String toString() => '${objectRuntimeType(this, 'SemanticsTag')}($name)';

}

class ChildSemanticsConfigurationsResult {

ChildSemanticsConfigurationsResult._(this.mergeUp, this.siblingMergeGroups);

/// Returns the [SemanticsConfiguration]s that are supposed to be merged into

final List<SemanticsConfiguration> mergeUp;

/// The groups of child semantics configurations that want to merge together

final List<List<SemanticsConfiguration>> siblingMergeGroups;

}

class ChildSemanticsConfigurationsResultBuilder {

/// Creates a [ChildSemanticsConfigurationsResultBuilder].

ChildSemanticsConfigurationsResultBuilder();

final List<SemanticsConfiguration> _mergeUp = <SemanticsConfiguration>[];

final List<List<SemanticsConfiguration>> _siblingMergeGroups = <List<SemanticsConfiguration>>[];

/// Marks the [SemanticsConfiguration] to be merged into the parent semantics

void markAsMergeUp(SemanticsConfiguration config) => _mergeUp.add(config);

/// Marks a group of [SemanticsConfiguration]s to merge together

void markAsSiblingMergeGroup(List<SemanticsConfiguration> configs) =>

_siblingMergeGroups.add(configs);

/// Builds a [ChildSemanticsConfigurationsResult] contains the arrangement.

ChildSemanticsConfigurationsResult build() {

assert(() {

final seenConfigs = <SemanticsConfiguration>{};

for (final config in <SemanticsConfiguration>[

..._mergeUp,

..._siblingMergeGroups.flattened,

]) {

assert(

seenConfigs.add(config),

'Duplicated SemanticsConfigurations. This can happen if the same '

'SemanticsConfiguration was marked twice in markAsMergeUp and/or '

'markAsSiblingMergeGroup',

);

}

return true;

}());

return ChildSemanticsConfigurationsResult._(_mergeUp, _siblingMergeGroups);

}

}

class CustomSemanticsAction {

/// Creates a new [CustomSemanticsAction].

const CustomSemanticsAction({required String this.label})

: assert(label != ''),

hint = null,

action = null;

/// Creates a new [CustomSemanticsAction] that overrides a standard semantics

const CustomSemanticsAction.overridingAction({

required String this.hint,

required SemanticsAction this.action,

}) : assert(hint != ''),

label = null;

/// The user readable name of this custom semantics action.

final String? label;

/// The hint description of this custom semantics action.

final String? hint;

/// The standard semantics action this action replaces.

final SemanticsAction? action;

@override

int get hashCode => Object.hash(label, hint, action);

@override

bool operator ==(Object other) {

if (other.runtimeType != runtimeType) {

return false;

}

return other is CustomSemanticsAction &&

other.label == label &&

other.hint == hint &&

other.action == action;

}

@override

String toString() {

return 'CustomSemanticsAction(${_ids[this]}, label:$label, hint:$hint, action:$action)';

}

// Logic to assign a unique id to each custom action without requiring

// user specification.

static int _nextId = 0;

static final Map<int, CustomSemanticsAction> _actions = <int, CustomSemanticsAction>{};

static final Map<CustomSemanticsAction, int> _ids = <CustomSemanticsAction, int>{};

/// Get the identifier for a given `action`.

static int getIdentifier(CustomSemanticsAction action) {

int? result = _ids[action];

if (result == null) {

result = _nextId++;

_ids[action] = result;

_actions[result] = action;

}

return result;

}

/// Get the `action` for a given identifier.

static CustomSemanticsAction? getAction(int id) {

return _actions[id];

}

/// Resets internal state between tests. Does nothing if asserts are disabled.

@visibleForTesting

static void resetForTests() {

assert(() {

_actions.clear();

_ids.clear();

_nextId = 0;

return true;

}());

}

}

class AttributedString {

/// Creates a attributed string.

AttributedString(this.string, {this.attributes = const <StringAttribute>[]})

: assert(string.isNotEmpty || attributes.isEmpty),

assert(() {

for (final attribute in attributes) {

assert(

string.length >= attribute.range.start && string.length >= attribute.range.end,

'The range in $attribute is outside of the string $string',

);

}

return true;

}());

/// The plain string stored in the attributed string.

final String string;

/// The attributes this string carries.

final List<StringAttribute> attributes;

/// Returns a new [AttributedString] by concatenate the operands

AttributedString operator +(AttributedString other) {

if (string.isEmpty) {

return other;

}

if (other.string.isEmpty) {

return this;

}

// None of the strings is empty.

final String newString = string + other.string;

final newAttributes = List<StringAttribute>.of(attributes);

if (other.attributes.isNotEmpty) {

final int offset = string.length;

for (final StringAttribute attribute in other.attributes) {

final newRange = TextRange(

start: attribute.range.start + offset,

end: attribute.range.end + offset,

);

final StringAttribute adjustedAttribute = attribute.copy(range: newRange);

newAttributes.add(adjustedAttribute);

}

}

return AttributedString(newString, attributes: newAttributes);

}

/// Two [AttributedString]s are equal if their string and attributes are.

@override

bool operator ==(Object other) {

return other.runtimeType == runtimeType &&

other is AttributedString &&

other.string == string &&

listEquals<StringAttribute>(other.attributes, attributes);

}

@override

int get hashCode => Object.hash(string, attributes);

@override

String toString() {

return "${objectRuntimeType(this, 'AttributedString')}('$string', attributes: $attributes)";

}

}

class AttributedStringProperty extends DiagnosticsProperty<AttributedString> {

/// Create a diagnostics property for an [AttributedString] object.

AttributedStringProperty(

String super.name,

super.value, {

super.showName,

this.showWhenEmpty = false,

super.defaultValue,

super.level,

super.description,

});

/// Whether to show the property when the [value] is an [AttributedString]

final bool showWhenEmpty;

@override

bool get isInteresting =>

super.isInteresting && (showWhenEmpty || (value != null && value!.string.isNotEmpty));

@override

String valueToString({TextTreeConfiguration? parentConfiguration}) {

if (value == null) {

return 'null';

}

String text = value!.string;

if (parentConfiguration != null && !parentConfiguration.lineBreakProperties) {

// This follows a similar pattern to StringProperty.

text = text.replaceAll('\n', r'\n');

}

if (value!.attributes.isEmpty) {

return '"$text"';

}

return '"$text" ${value!.attributes}'; // the attributes will be in square brackets since they're a list

}

}

typedef _LabelPart = (String text, TextDirection? textDirection);