Exploring Writing Tools: Rewriting a Post About Writing Tools using Writing Tools

I let the dramatic me a bit wild on this one. Let‘s create notes about the WWDC session on Writing Tools while rewriting it using Writing Tools. I am writing it on my M2 iPad Air running iPadOS 18.1 beta 1 and editing it on my Mac Mini running macOS Sequoia 15.1 beta 1.

Rewrite: I indulged in a bit of dramatic flair while crafting this piece. Let’s document the WWDC session on Writing Tools while simultaneously rewriting it using Writing Tools. I’m writing this on my M2 iPad Air, running iPadOS 18.1 beta 1, and editing it on my Mac Mini, running macOS Sequoia 15.1 beta 1.

Friendly: I got a bit carried away with the dramatic side of things. Let’s create some notes about the WWDC session on Writing Tools while we’re rewriting it using Writing Tools. I’m writing it on my M2 iPad Air running iPadOS 18.1 beta 1 and editing it on my Mac Mini running macOS Sequoia 15.1 beta 1.

Professional: In this instance, I indulged my dramatic tendencies somewhat. Let us meticulously document the WWDC session on Writing Tools while simultaneously rewriting it using Writing Tools. I am currently composing this document on my M2 iPad Air, which is powered by iPadOS 18.1 beta 1, and I am editing it on my Mac Mini, which is equipped with macOS Sequoia 15.1 beta 1.

Concise: Let’s create notes about the WWDC session on Writing Tools while rewriting it using Writing Tools. I’m writing on my M2 iPad Air running iPadOS 18.1 beta 1 and editing on my Mac Mini running macOS Sequoia 15.1 beta 1.

Introduction

From everything that I have read and watched about Writing Tools, my takeaway is that it helps users polish the text they are working on. Not write for them. But assist and enhance their words and sentences.

It helps to proofread (similar to Grammarly but on-device), rewrite the text in a better or worse way (left to our interpretation), and transform the text like creating tables, lists or summaries on iOS, iPadOS and macOS.

Here is an example of how the overlay of Writing Tools looks like:

Rewrite: Based on my reading and viewing of various resources about Writing Tools, I’ve come to the conclusion that it primarily assists users in refining their written work rather than dictating it. It serves as a tool to enhance and improve their words and sentences.

One of its key features is the ability to proofread text, similar to Grammarly, but conveniently on-device. Additionally, it offers the option to rewrite the text in a manner that suits the user’s preferences, leaving the interpretation to their discretion. Furthermore, Writing Tools enables users to transform their text by creating tables, lists, or summaries on iOS, iPadOS, and macOS.

Here’s an illustration of how the overlay of Writing Tools appears:

Friendly: Based on everything I’ve read and watched about Writing Tools, I’ve come to the conclusion that it’s all about helping users refine their writing. It’s not about writing for them, but rather about assisting and enhancing their words and sentences.

Here are some of the features Writing Tools offers:
- Proofreading (similar to Grammarly, but right on your device)
- Rewriting the text in a better or worse way (up to your interpretation)
- Creating tables, lists, or summaries on iOS, iPadOS, and macOS

Here’s an example of how the Writing Tools overlay looks like:

Professional: Based on my extensive reading and viewing of various resources on Writing Tools, I have concluded that the primary function of these tools is to assist users in refining and enhancing their textual content rather than serving as a substitute for writing.

Writing Tools offer a range of functionalities, including:
- Proofreading: Similar to Grammarly, Writing Tools provide on-device proofreading capabilities.
- Text Rewriting: Users can experiment with different text rewrites, allowing for creative expression and exploration of various writing styles.
- Text Transformation: Writing Tools enable users to transform text into various formats, such as tables, lists, and summaries, making it accessible and user-friendly across iOS, iPadOS, and macOS.

For instance, here is an illustration of the Writing Tools overlay:

Concise: Writing Tools helps users polish their text, not write for them. It assists and enhances their words and sentences. It offers features like proofreading (similar to Grammarly), rewriting text, and transforming it into tables, lists, or summaries on iOS, iPadOS, and macOS. Here’s an example of the Writing Tools overlay:

Accessing Writing Tools

If you are using native text views in iOS or iPadOS, then an option appears on top of the selected text as a popover alongside cut/copy/paste. On macOS, it is available as context menu and edit menu. I do wonder if it shows up on the Touch Bar on the MacBook Pro that are running Apple Silicon...

Rewrite: If you’re using native text views in iOS or iPadOS, you’ll notice a popover appearing above the selected text, offering cut, copy, and paste options. On macOS, it’s accessible through the context menu and edit menu. I’m curious to know if this feature is also available on the Touch Bar on MacBook Pros running Apple Silicon.

Friendly: If you’re using native text views in iOS or iPadOS, you’ll see a popover on top of the selected text, just like cut, copy, and paste. On macOS, it’s in the context menu and edit menu. I’m curious if it shows up on the Touch Bar on the MacBook Pro with Apple Silicon…

Professional: If you are utilizing native text views in iOS or iPadOS, an option appears atop the selected text as a popover, alongside the cut, copy, and paste commands. On macOS, it is accessible through the context menu and edit menu. I am curious to know if it is also present on the Touch Bar on the MacBook Pro models that are powered by Apple Silicon.

Concise: If using native text views in iOS or iPadOS, a popover appears alongside cut/copy/paste. On macOS, it’s in the context menu and edit menu. Is it on the Touch Bar on MacBook Pro with Apple Silicon?

Writing Tools Capabilities

As shown in the popover above, Writing Tools does have a lot to offer. Based on my experience of using it, it is better than other LLMs that heavily rely on AI cliche words that are game changer while we delve into Writing Tools to elevate and foster ourselves into the realm of infinity.

Rewrite: As demonstrated in the popover above, Writing Tools offers a wealth of features. Based on my personal experience using it, it surpasses other LLMs that heavily rely on AI-generated clichés that are supposedly groundbreaking. However, when we explore Writing Tools, we discover its potential to elevate and empower us to transcend the boundaries of human capabilities.

Friendly: Writing Tools is packed with features, as shown in the popover above. Based on my experience using it, it’s way better than other LLMs that rely on overused AI clichés that feel outdated. Let’s dive into Writing Tools and use it to level up our writing skills and reach new heights!

Professional: As demonstrated in the popover above, Writing Tools possesses a comprehensive suite of features. Based on my personal experience utilizing it, it surpasses other LLMs that heavily rely on AI-generated clichés that have proven to be transformative. However, as we delve deeper into Writing Tools, we discover that it empowers and fosters our growth, enabling us to transcend the limitations of the finite realm.

Concise: Writing Tools offers a lot, as shown in the popover. It’s better than other LLMs that rely heavily on AI cliches. Let’s use Writing Tools to elevate ourselves into the realm of infinity.

The first one is proofreading. It shows mistakes like misspellings and grammar errors. My tenses have always been tense enough for a grammar pedant to cancel me for it. I have not re-subscribed to Grammarly, so I look forward to using more of Writing Tools.

The second feature is rewriting. We are already seeing it all over this post. We can adjust the tone to be more friendly, professional or concise.

The third feature is about transforming the whole text itself, from summarising the text to creating key points. It is fun that we can convert the texts into lists and tables too!

For places that have non-editable texts, the results is shown as a sheet that can be copied or shared.

Key Points:

• Proofreading: Writing Tools can identify spelling and grammar errors.
• Rewriting: Users can adjust the tone of their writing to be more friendly, professional, or concise.

List:

• Proofreading: Shows mistakes like misspellings and grammar errors.
• Rewriting: Adjusts the tone to be more friendly, professional, or concise.
• Transforming: Creates key points, summarizes the text, and converts it into lists and tables.
• Non-editable texts: Results are shown as a sheet that can be copied or shared.

Rewrite: The first tool I’m excited to try is Proofreading. It helps me catch mistakes like misspellings and grammar errors. My grammar has always been a bit of a challenge, and I’ve been told by grammar pedants that my tenses are inconsistent. I haven’t re-subscribed to Grammarly, so I’m looking forward to using Writing Tools to improve my grammar.

The second feature is rewriting. We can adjust the tone to be more friendly, professional, or concise.

The third feature is transforming the entire text, from summarizing it to creating key points. I’ll provide both for the article at the end. It’s fun that we can convert texts into lists and tables too!

For places where non-editable texts are present, the results are displayed as a sheet that can be copied or shared.

Friendly: The first one is proofreading. It highlights mistakes like misspellings and grammar errors. My tenses have always been a bit too loose for a grammar snob to cancel me for it. I haven’t re-subscribed to Grammarly, so I’m excited to explore more of Writing Tools.

The second feature is rewriting. You’ll see it everywhere in this post. We can change the tone to be friendly, professional, or short and sweet.

The third feature is about transforming the whole text, from summarizing it to creating key points. It’s so cool that we can convert the texts into lists and tables too!

For places where you can’t edit the text, the results are shown as a sheet that you can copy or share.

Professional: The initial task is proofreading, which identifies errors such as misspellings and grammar mistakes. My writing style has consistently been deemed inadequate by grammar pedants, leading to my disqualification. Consequently, I have discontinued my subscription to Grammarly. I eagerly anticipate utilizing Writing Tools extensively in the future.

The second feature is rewriting. We are already witnessing this throughout the post. We can adjust the tone to be more friendly, professional, or concise.

The third feature is about transforming the entire text itself, from summarizing the text to creating key points. It is intriguing that we can convert the texts into lists and tables as well!

For places where non-editable texts are present, the results are displayed as a sheet that can be copied or shared.

Concise: Proofreading checks for mistakes like misspellings and grammar errors. My tense issues usually get me flagged by grammar pedants. I haven’t re-subscribed to Grammarly, so I’m excited to use more Writing Tools.

Rewriting is the second feature. We can adjust the tone to be friendly, professional, or concise.

The third feature transforms the text, from summarizing to creating key points. We can even convert texts into lists and tables!

For non-editable texts, the results are shown as a copyable or shareable sheet.

Writing Tools and Text Views

If you have been a good native Apple citizen developer and used UITextView, NSTextView or WKWebView, then you do not have to do anything. It will work automatically. However, for the full experience of Writing Tools, you need to be using TextKit 2. You get a limited experience with TextKit 1.

Rewrite: If you’ve been a diligent native Apple citizen developer and used UITextView, NSTextView, or WKWebView, you don’t need to take any action. These features will work seamlessly. However, for the full range of Writing Tools features, you must be using TextKit 2. TextKit 1 provides a limited experience.

Friendly: If you’re a seasoned native Apple developer who’s used UITextView, NSTextView, or WKWebView, you don’t need to worry about anything. It’ll work perfectly on its own. But for the full Writing Tools experience, you’ll need to use TextKit 2. With TextKit 1, you’ll get a limited experience.

Professional: If you have been a diligent native Apple developer who has utilized UITextView, NSTextView, or WKWebView, you are not required to take any further action. The functionality will be automatically activated. However, to fully experience the capabilities of Writing Tools, it is imperative that you utilize TextKit 2. In contrast, TextKit 1 provides a limited experience.

Concise: If you’re a good native Apple citizen developer who’s used UITextView, NSTextView, or WKWebView, you don’t need to do anything. It works automatically. For the full Writing Tools experience, use TextKit 2. TextKit 1 provides limited support.

How It Works

As a user, to make the most out of the Writing Tools, we need to make sure we select enough words and sentences to provide more context to the model. You do not have to worry about bold, or italics, or underlined texts as it supports rich attributed strings and preserves the styles, links and attachments.

Rewrite: To maximize the effectiveness of the Writing Tools, we must ensure that we provide sufficient words and sentences to provide context to the model. Rest assured, bold, italics, and underlined texts are supported, and the tool preserves the styles, links, and attachments.

Friendly: To get the most out of the Writing Tools, we need to give it some context by adding enough words and sentences. Don’t worry about bold, italics, or underlined texts - it can handle rich attributed strings and keeps the styles, links, and attachments intact.

Professional: As a user, to maximize the effectiveness of the Writing Tools, it is imperative that we select an adequate number of words and sentences to provide sufficient context for the model. The tool does not require the use of bold, italics, or underlined text, as it supports rich attributed strings and preserves the styles, links, and attachments.

Concise: To maximize the Writing Tools, select enough words and sentences to provide context to the model. It supports rich attributed strings, preserving styles, links, and attachments.

Updating Views When Model Processing

When you or the user selects the texts and selects one of the options from Writing Tools, the popover shows an animation to indicate that the model is processing the text and a session is active. If you are syncing the text to the cloud, or want to avoid accidental editing, the team has two delegate methods for you and a property of the text view to check if Writing Tools is active. These are available for both UITextView and NSTextView:

func textViewWritingToolsWillBegin(_ textView: UITextView) {
  // Take necessary steps to prepare. For example, disable iCloud sync.
}

func textViewWritingToolsDidEnd(_ textView: UITextView) {
  // Take necessary steps to recover. For example, reenable iCloud sync.
}

if !textView.isWritingToolsActive {
  // Do work that needs to be avoided when Writing Tools is interacting with text view
  
  // For example, in the textViewDidChange callback, app may want to avoid certain things when Writing Tools is active
}

Rewrite: When you or the user selects the texts and chooses one of the options from the Writing Tools, a popover appears to indicate that the model is processing the text and that a session is active. If you’re syncing the text to the cloud or want to prevent accidental editing, the team provides two delegate methods and a property of the text view to check if Writing Tools is active. These methods are available for both UITextView and NSTextView.

Friendly: When you or the user picks the texts and chooses one of the options from Writing Tools, a popover shows an animation to let you know that the model is processing the text and that a session is active. If you’re syncing the text to the cloud or want to avoid accidental editing, the team has two delegate methods for you and a property of the text view to check if Writing Tools is active. These are available for both UITextView and NSTextView:

Professional: Upon selecting the texts and selecting an option from the Writing Tools popover, an animation is displayed to indicate that the model is processing the text and a session is active. If you are syncing the text to the cloud or wish to prevent accidental editing, the team has provided two delegate methods and a property of the text view to determine if Writing Tools is active. These methods are available for both UITextView and NSTextView.

Concise: When you or the user selects texts and options from Writing Tools, a popover shows an animation indicating the model’s processing and an active session. For syncing or avoiding accidental editing, the team provides delegate methods and a text view property to check Writing Tools’s activity. These are available for UITextView and NSTextView.

Customizing Writing Tools Behavior

While it makes sense to let the users take full advantage of the new Writing Tools, there may be cases where you would want limited behaviour that just shows a copy or share sheet, or even opt out of the experience all together. You can set the behaviour like this:

textView.writingToolsBehavior = .limited

textView.writingToolsBehavior = .none

You can also make edit the type of input options that Writing tools can have:

textview.writingToolsAllowedInputOptions = [.plainText]


textview.writingToolsAllowedInputOptions = [.plainText, .richText, .table]

By default, it is set to both plain and rich text, excluding tables.

There are similar APIs for WKWebView but the default behaviour is set to limited instead of default set for native text views:

// For `WKWebView`, the `default` behavior is equivalent to `.limited`

extension WKWebViewConfiguration {
  @available(iOS 18.0, *)
  open var writingToolsBehavior: UIWritingToolsBehavior { get set }
}

extension WKWebViewConfiguration {
  @available(macOS 15.0, *)
  open var writingToolsBehavior: NSWritingToolsBehavior { get set }
}

extension WKWebView {
  // @discussion If the Writing Tools behavior on the configuration is `.limited`, this will always be `false`.
  @available(iOS 18.0, macOS 15.0, *)
  open var isWritingToolsActive: Bool { get }
}

Rewrite: While it’s understandable to allow users to fully utilize the new Writing Tools, there might be instances where you’d prefer limited functionality, such as displaying a copy or share sheet, or even opting out of the experience altogether. To achieve this, you can configure the behavior as follows:

Additionally, you can modify the type of input options that Writing Tools can accept:

By default, it’s set to both plain and rich text, excluding tables. Similar APIs exist for WKWebView, but the default behavior is set to limited instead of the default setting for native text views.

Friendly: It’s great that users can fully enjoy the new Writing Tools. But there might be times when you’d prefer a more limited experience, like showing just a copy or share sheet, or even turning it off altogether. You can control this behavior like this: You can also change the type of input options that Writing Tools can have: By default, it’s set to both plain and rich text, excluding tables.p

There are similar APIs for WKWebView, but the default behavior is set to limited instead of the default for native text views:

Professional: While it is prudent to allow users to fully utilize the new Writing Tools, there may be instances where you would prefer restricted behavior, such as displaying a copy or share sheet or opting out of the experience altogether. You can configure this behavior as follows: Additionally, you can modify the input options that Writing Tools can accept: By default, these options are set to both plain and rich text, excluding tables. There are similar APIs for WKWebView, but the default behavior is set to limited instead of the default setting for native text views.

Concise: You can set limited behavior for the new Writing Tools, such as showing a copy or share sheet or opting out of the experience. You can also edit the input options for Writing tools. By default, it’s set to plain and rich text, excluding tables. Similar APIs for WKWebView have a default behavior of limited instead of default for native text views.

Protecting Specific Text Ranges

The team behind Writing Tools have been kind enough to think beyond the normal text editors, and support more delegate methods, especially when you want to ignore texts in certain cases like code blocks or quoted mails.

// Returned `NSRange`s are relative to the substring of the textView’s textStorage from `enclosingRange`
func textView(_ textView: UITextView, writingToolsIgnoredRangesIn
        enclosingRange: NSRange) -> [NSRange] {
    let text = textView.textStorage.attributedSubstring(from: enclosingRange)
    return rangesInappropriateForWritingTools(in: text)
}

These text will be ignored by Writing Tools and not rewritten or transformed. Same for tags like <blockquote> and <pre> when it comes to WKWebView.

Rewrite: The team behind Writing Tools has demonstrated their innovative spirit by extending the capabilities of text editors beyond the conventional. They have introduced delegate methods that enable users to selectively ignore certain text elements, such as code blocks and quoted emails.

When determining which text ranges to ignore, the returned `NSRange`s are relative to the substring of the textView’s textStorage within the enclosing range.

In this context, the following text will be ignored by Writing Tools and not rewritten or transformed:
- Code blocks
- Quoted emails
- Tags like <blockquote> and <pre> when used in WKWebView.

Friendly: The team behind Writing Tools has gone above and beyond the usual text editors. They’ve added more delegate methods, especially when you want to ignore certain texts like code blocks or quoted mails.

These text will be ignored by Writing Tools and not rewritten or transformed. Same for tags like <blockquote> and <pre> when it comes to WKWebView.

Professional: The team behind Writing Tools has demonstrated exceptional innovation by extending the capabilities of text editors beyond the conventional realm. This extension enables the support of delegate methods, particularly when it comes to the exclusion of specific text segments, such as code blocks or quoted emails.

Text elements that Writing Tools deems inappropriate for editing will be disregarded and not rewritten or transformed. This includes tags such as <blockquote> and <pre> when rendering in WKWebView.

Concise: The Writing Tools team supports delegate methods beyond the usual text editors, especially for ignoring texts like code blocks or quoted mails.

These texts will be ignored by Writing Tools and not rewritten or transformed. Same for tags like <blockquote> and <pre> in WKWebView.

Supporting Custom Text Views

If you have made it till here, the probability of your app having a custom text view is high, or maybe you like my writing style, too!

On iOS and iPadOS, if your custom view supports UITextInteraction, you will get Writing Tools. Congratulations! If not, you can adopt UITextSelectionDisplayInteraction with UIEditMenuInteraction too. To be honest, I have not worked with either, so I hope they are cool APIs to play around with.

Use the isEditable property to indicate that your text view supports editing:

protocol UITextInput {
  @available(iOS 18.0, macOS 15.0, *)
  optional var isEditable: Bool { get }
}

For macOS, make sure your text view adopts NSServicesMenuRequestor that allows to read and write content of the view:

class CustomTextView: NSView, NSServicesMenuRequestor {
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        
        self.menu = NSMenu()
        self.menu?.addItem(NSMenuItem(title: "Custom Text View", action: nil,
            keyEquivalent: ""))
        self.menu?.addItem(NSMenuItem(title: "Copy", action: #selector(copy(_:)), 
            keyEquivalent: ""))
    }
  
    override func draw(_ dirtyRect: NSRect) {
        super.draw(dirtyRect)
        
        // Custom text drawing code...
    }
}

class CustomTextView: NSView, NSServicesMenuRequestor {
    override func validRequestor(forSendType sendType: NSPasteboard.PasteboardType?, 
                                 returnType: NSPasteboard.PasteboardType?) -> Any? {
        if sendType == .string || sendType == .rtf {
            return self
        }
        return super.validRequestor(forSendType: sendType, returnType: returnType)
    }
    
    nonisolated func writeSelection(to pboard: NSPasteboard,
                                    types: [NSPasteboard.PasteboardType]) -> Bool {
        // Write plain text and/or rich text to pasteboard
        return true
    }

    // Implement readSelection(from pboard: NSPasteboard)
       as well for editable view
}

Rewrite: If you’ve made it this far, the likelihood of your app having a custom text view is high, or perhaps you appreciate my writing style as well!

On iOS and iPadOS, if your custom view supports UITextInteraction, you’ll be able to access Writing Tools. Congratulations! If not, you can also adopt UITextSelectionDisplayInteraction and UIEditMenuInteraction. Honestly, I haven’t worked with either of these APIs, so I hope they’re cool to experiment with.

To indicate that your text view supports editing, use the isEditable property of the UITextInput protocol.

For macOS, ensure that your text view adopts NSServicesMenuRequestor, which allows you to read and write content from the view.

Friendly: If you’ve made it this far, there’s a good chance your app has a custom text view. Or maybe you just like my writing style!

On iOS and iPadOS, if your custom view supports UITextInteraction, you’ll get Writing Tools. Congrats! If not, you can also use UITextSelectionDisplayInteraction with UIEditMenuInteraction. I haven’t worked with either, so I hope they’re cool APIs to play with.

To let your text view know it’s editable, use the isEditable property of the UITextInput protocol.

For macOS, make sure your text view adopts NSServicesMenuRequestor that allows you to read and write content in the view.

Professional: If you have reached this point, the likelihood of your application incorporating a custom text view is high, or perhaps you appreciate my writing style.

On iOS and iPadOS, if your custom view implements UITextInteraction, you will be granted Writing Tools. Congratulations! If not, you can also adopt UITextSelectionDisplayInteraction and UIEditMenuInteraction. To be honest, I have not personally worked with either, so I trust they are user-friendly APIs to experiment with.

Utilize the isEditable property to indicate that your text view supports editing:

For macOS, ensure that your text view adopts NSServicesMenuRequestor, which enables the reading and writing of content within the view.

Concise: If you’ve made it this far, your app likely has a custom text view. If not, you can use UITextSelectionDisplayInteraction or UIEditMenuInteraction. I haven’t worked with either, but they seem cool APIs.

Use the isEditable property to indicate your text view supports editing.

Moving Forward

If your app has some sort of text-related functionality, then you should try out the new beta of iOS/iPadOS 18.1 and macOS 15.1 and give Writing Tools a try. It should hopefully just work!

And as Liu mentioned at the end of the session, enjoy writing!

Rewrite: If your app incorporates text-related functionality, you should explore the new beta of iOS/iPadOS 18.1 and macOS 15.1. Additionally, you can give Writing Tools a try. It’s expected to function seamlessly.

As Liu concluded the session, I encourage you to enjoy the process of writing!

Friendly: If your app has any text-related features, you should definitely check out the new beta of iOS/iPadOS 18.1 and macOS 15.1. You can try out Writing Tools. It should work just fine!

And as Liu mentioned at the end of the session, don’t forget to enjoy writing!

Professional: If your application incorporates text-related functionality, I recommend exploring the newly released beta version of iOS/iPadOS 18.1 and macOS 15.1. I suggest you experiment with the Writing Tools feature. The functionality is anticipated to be seamless.

As Liu concluded the session, I encourage you to embrace the joy of writing.

Concise: If your app has text-related functionality, try the new beta of iOS/iPadOS 18.1 and macOS 15.1’s Writing Tools. It should work!

Enjoy writing!

Summary

Writing Tools assists users in refining their writing by providing proofreading, rewriting, and text transformation features. It offers a popover with options for cut, copy, and paste on iOS and iPadOS, and is accessible through the context menu and edit menu on macOS. The tool can be used to create tables, lists, and summaries, and can be accessed in non-editable areas as a sheet that can be copied or shared.

Writing Tools offers three main features: proofreading, rewriting, and text transformation. It supports rich attributed strings and preserves styles, links, and attachments. Users can customize Writing Tools’ behavior, allowing limited functionality or opting out altogether.

Writing Tools in iOS/iPadOS 18.1 and macOS 15.1 offer users a range of options to customize their writing experience. Developers can control the behavior of Writing Tools, including limiting its functionality or disabling it altogether. Additionally, developers can ignore specific text ranges, such as code blocks or quoted emails, and support custom text views by implementing the necessary protocols.

Table