@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.0

package/pipeline/skills/shared/external/natural-language/evals/evals.json

@@ -4,43 +4,43 @@
     {
       "id": 0,
       "name": "text-analysis-pipeline",
-      "prompt": "I'm adding an iOS 26 inbox feature that detects the message language, tokenizes words, extracts people and organizations, computes a sentiment score, and finds semantically similar keywords for search suggestions. Sketch the NaturalLanguage implementation and review checklist.",
-      "expected_output": "A NaturalLanguage implementation outline that uses NLTokenizer, NLLanguageRecognizer, NLTagger, and NLEmbedding accurately, handles language/support limits, and avoids thread-safety and per-token tagger mistakes.",
+      "prompt": "Our support inbox app receives short customer messages in many languages. For each message we want the language, any people, places and companies mentioned, an overall mood score, and a list of similar past keywords. Processing runs on a background queue with several workers. Design the NaturalLanguage side.",
+      "expected_output": "Picks sensible token units, keeps every NLTokenizer and NLTagger confined to one worker at a time, uses languageConstraints or languageHints because messages are short, tags entities with the .nameType scheme and scores mood with .sentimentScore, passes .omitWhitespace, .omitPunctuation and .joinNames, handles optional tags and sentiment without force unwraps, and checks that a word embedding exists before using it.",
       "files": [],
       "expectations": [
-        "Uses NLTokenizer with the correct token unit and keeps tokenizer/tagger instances confined to one thread or dispatch queue at a time.",
-        "Uses NLLanguageRecognizer with languageConstraints or languageHints when text is short or expected languages are known.",
-        "Uses NLTagger with .nameType, .sentimentScore, and appropriate options such as .omitWhitespace, .omitPunctuation, and .joinNames.",
-        "Treats sentiment and tags as optional and handles unsupported languages or missing tag schemes instead of force-unwrapping.",
-        "Checks NLEmbedding word or sentence embedding availability and does not assume embeddings exist for every language."
+        "Chooses appropriate tokenizer units and confines each tokenizer or tagger to a single thread",
+        "Adds languageConstraints or languageHints for short messages",
+        "Uses .nameType for entities and .sentimentScore for mood",
+        "Uses the options .omitWhitespace, .omitPunctuation and .joinNames",
+        "Handles optional tags, sentiment and embeddings without force unwrapping"
       ]
     },
     {
       "id": 1,
       "name": "translation-availability-review",
-      "prompt": "Review this SwiftUI translation plan: use the system translation popover on iOS 17.4, use TranslationSession and .translationTask for programmatic batch translation on the same deployment target, prefer .highFidelity because it can use a server, and ignore errors because the framework downloads languages automatically.",
-      "expected_output": "A correction-focused Translation framework review that splits API availability, keeps translation on-device, handles language availability and throwing APIs, and explains SwiftUI and direct-session usage safely.",
+      "prompt": "Review our plan: we target iOS 17.4, call TranslationSession directly on launch with the high-fidelity strategy because it uses the cloud, and translate our menu in one batch without any error handling. What is wrong?",
+      "expected_output": "Separates availability: the system translation sheet exists from iOS 17.4, whereas iOS 18 is the floor for sessions, the translationTask modifier, LanguageAvailability and batches, and strategies need 26.4. Corrects the claim that .highFidelity uses a server: translation runs on device, with .highFidelity preferring Apple Intelligence models and .lowLatency the classic models. Uses LanguageAvailability with its installed, supported and unsupported states, puts every translate, translations(from:) and prepareTranslation call inside do-catch, and explains that TranslationSession(installedSource:target:) needs both languages installed while translationTask can prompt for downloads.",
       "files": [],
       "expectations": [
-        "Separates translationPresentation availability from TranslationSession, translationTask, LanguageAvailability, and batch translation availability.",
-        "Corrects highFidelity/lowLatency guidance without claiming TranslationSession sends content to a server.",
-        "Uses LanguageAvailability status checks and handles .installed, .supported, and .unsupported.",
-        "Wraps TranslationSession throwing calls such as translate, translations(from:), and prepareTranslation in error handling.",
-        "Explains that direct TranslationSession(installedSource:target:) outside SwiftUI requires installed languages, while SwiftUI translationTask can request downloads."
+        "Distinguishes the 17.4 presentation API from the iOS 18 session, task, availability and batch APIs",
+        "States that neither strategy sends text to a server",
+        "Lists the .installed, .supported and .unsupported availability states",
+        "Catches errors from translate, translations(from:) and prepareTranslation",
+        "Explains that the installedSource initializer requires installed languages whereas translationTask can request downloads"
       ]
     },
     {
       "id": 2,
       "name": "sibling-boundary-routing",
-      "prompt": "I have one feature request: scan text from a receipt image, transcribe a spoken note, tokenize and identify the language of the resulting text, detect names and sentiment, find semantically similar keywords with embeddings, maybe add a custom text classifier/tagger, translate a summary to Spanish, localize UI strings with String Catalogs (.xcstrings), plurals, RTL, date and currency formatting, and maybe use Apple Intelligence to generate the summary. Which parts belong in the NaturalLanguage skill and which should be handed to sibling skills?",
-      "expected_output": "A boundary-aware routing answer that keeps NaturalLanguage/Translation responsible for text analysis and translation, and routes OCR, speech transcription, localization, and generative summarization to the appropriate sibling skills.",
+      "prompt": "Our travel journal app scans printed tickets, dictates voice notes, shows its UI in eight languages, summarizes each trip, and tags places and moods in the journal text. Which parts belong to the NaturalLanguage skill and which go elsewhere?",
+      "expected_output": "Keeps tokenization, language identification, entity extraction, sentiment, embeddings and translation of journal text in this skill. Ticket OCR goes to vision-framework, voice-note transcription to speech-recognition, String Catalogs, plurals and formatting to ios-localization, and generated trip summaries to apple-on-device-ai.",
       "files": [],
       "expectations": [
-        "Keeps tokenization, language identification, named entity recognition, sentiment analysis, embeddings, and in-app translation in the natural-language scope.",
-        "Routes receipt-image OCR to the Vision framework skill rather than treating NaturalLanguage as OCR.",
-        "Routes spoken-note transcription to the Speech framework skill rather than treating NaturalLanguage as speech recognition.",
-        "Routes UI strings, String Catalogs, pluralization, and locale-aware formatting to the iOS localization skill.",
-        "Routes Apple Intelligence or generative summarization to the on-device AI skill rather than presenting NaturalLanguage as a generative LLM framework."
+        "Keeps tokenization, language identification, entities, sentiment, embeddings and translation here",
+        "Sends ticket OCR to vision-framework",
+        "Sends voice-note transcription to speech-recognition",
+        "Sends UI strings, plurals and formatting to ios-localization",
+        "Sends generated trip summaries to apple-on-device-ai"
       ]
     }
   ]

package/pipeline/skills/shared/external/natural-language/references/translation-patterns.md

@@ -1,324 +1,270 @@
-# NaturalLanguage + Translation Extended Patterns
+# Translation and text-analysis patterns
 
-Overflow reference for the `natural-language` skill. Contains advanced patterns
-that exceed the main skill file's scope.
+Deeper material for the `natural-language` skill ([../SKILL.md](../SKILL.md)).
 
-## Contents
+## Plugging in a Create ML model
 
-- [Custom NLModel Integration](#custom-nlmodel-integration)
-- [Contextual Embeddings](#contextual-embeddings)
-- [Gazetteers for Domain Vocabulary](#gazetteers-for-domain-vocabulary)
-- [NLTagger with Multiple Schemes](#nltagger-with-multiple-schemes)
-- [Translation with Replacement Action](#translation-with-replacement-action)
-- [Translation Session Strategies](#translation-session-strategies)
-- [SwiftUI Integration Patterns](#swiftui-integration-patterns)
-- [Lemmatization](#lemmatization)
-
-## Custom NLModel Integration
-
-Load a Create ML text classifier or word tagger into `NLTagger` via `NLModel`.
+A text classifier or word tagger trained in Create ML is loaded as an
+`MLModel`, wrapped in `NLModel`, and then either attached to a tagger or
+called directly.
 
 ```swift
-import NaturalLanguage
 import CoreML
+import NaturalLanguage
 
-func setupCustomTagger() throws -> NLTagger {
-    let mlModel = try MLModel(contentsOf: modelURL)
-    let nlModel = try NLModel(mlModel: mlModel)
-
-    let tagger = NLTagger(tagSchemes: [.nameType])
-    tagger.setModels([nlModel], forTagScheme: .nameType)
-    return tagger
-}
-
-// Direct prediction without a tagger
-func classifyText(_ text: String) throws -> String? {
-    let mlModel = try MLModel(contentsOf: modelURL)
-    let nlModel = try NLModel(mlModel: mlModel)
-    return nlModel.predictedLabel(for: text)
+func makeTicketTagger(modelURL: URL) throws -> (NLTagger, NLModel) {
+    let compiled = try MLModel(contentsOf: modelURL)
+    let wrapper = try NLModel(mlModel: compiled)
+    let routing = NLTagScheme("TicketRouting")
+    let tagger = NLTagger(tagSchemes: [routing])
+    tagger.setModels([wrapper], forTagScheme: routing)
+    return (tagger, wrapper)
 }
 
-// Predictions with confidence scores
-func classifyWithConfidence(_ text: String) throws -> [String: Double] {
-    let mlModel = try MLModel(contentsOf: modelURL)
-    let nlModel = try NLModel(mlModel: mlModel)
-    return nlModel.predictedLabelHypotheses(for: text, maximumCount: 5)
+func triage(_ ticket: String, with wrapper: NLModel) -> (String?, [String: Double]) {
+    let top = wrapper.predictedLabel(for: ticket)
+    let spread = wrapper.predictedLabelHypotheses(for: ticket, maximumCount: 3)
+    return (top, spread)
 }
 ```
 
-## Contextual Embeddings
+## Contextual embeddings
 
-`NLContextualEmbedding` produces context-aware vectors where the same word
-gets different vectors based on surrounding text.
+`NLContextualEmbedding` produces vectors that depend on the surrounding
+words, so "bank" in "river bank" and "bank loan" get different values. The
+initializer is failable, and the model assets may need a download first.
 
 ```swift
-import NaturalLanguage
+func tokenVectors(for text: String) async throws -> [[Double]] {
+    guard let model = NLContextualEmbedding(language: .english) else { return [] }
 
-func contextualVectors(for text: String) throws -> [([Double], Range<String.Index>)] {
-    guard let embedding = NLContextualEmbedding(language: .english) else {
-        return []
-    }
-
-    // Check and load assets
-    guard embedding.hasAvailableAssets else {
-        embedding.requestAssets { result, error in
-            // Handle download
-        }
-        return []
+    if !model.hasAvailableAssets {
+        let outcome = try await model.requestAssets()
+        guard outcome == .available else { return [] }
     }
 
-    try embedding.load()
-    defer { embedding.unload() }
+    try model.load()
+    defer { model.unload() }
 
-    let result = try embedding.embeddingResult(for: text, language: .english)
-    var vectors: [([Double], Range<String.Index>)] = []
-
-    result.enumerateTokenVectors(in: text.startIndex..<text.endIndex) { vector, range in
-        vectors.append((vector, range))
+    let result = try model.embeddingResult(for: text, language: .english)
+    var vectors: [[Double]] = []
+    let whole = text.startIndex..<text.endIndex
+    result.enumerateTokenVectors(in: whole) { vector, _ in
+        vectors.append(vector)
         return true
     }
     return vectors
 }
 ```
 
-### Finding Available Contextual Embeddings
+A completion-handler form, `requestAssets { result, error in }`, is also
+available. To see which models exist for a language:
 
 ```swift
-let embeddings = NLContextualEmbedding.contextualEmbeddings(forValues: [
-    .languages: [NLLanguage.english.rawValue]
-])
-
-for embedding in embeddings {
-    print("Model: \(embedding.modelIdentifier)")
-    print("Dimension: \(embedding.dimension)")
-    print("Max length: \(embedding.maximumSequenceLength)")
+let candidates = NLContextualEmbedding.contextualEmbeddings(
+    forValues: [.languages: [NLLanguage.german.rawValue]]
+)
+for model in candidates {
+    print(model.modelIdentifier, model.dimension, model.maximumSequenceLength)
 }
 ```
 
-## Gazetteers for Domain Vocabulary
+## Gazetteers for your own vocabulary
 
-Override or supplement tagger results with custom term-to-label mappings.
+A gazetteer maps known terms to labels and overrides or supplements what the
+tagger would say. Useful for product names, internal teams or medical terms.
 
 ```swift
-func setupGazetteer() throws -> NLTagger {
-    let dictionary: [String: [String]] = [
-        "PRODUCT": ["iPhone", "MacBook Pro", "Apple Watch"],
-        "FEATURE": ["Dynamic Island", "ProMotion", "MagSafe"]
-    ]
-
-    let gazetteer = try NLGazetteer(dictionary: dictionary, language: .english)
-    let tagger = NLTagger(tagSchemes: [.nameType])
-    tagger.setGazetteers([gazetteer], for: .nameType)
-    return tagger
-}
+let catalogue = try NLGazetteer(
+    dictionary: [
+        "Product": ["Aurora Hub", "Nimbus Cam"],
+        "Team": ["Platform Guild", "Night Shift"]
+    ],
+    language: .english
+)
+let tagger = NLTagger(tagSchemes: [.nameType])
+tagger.setGazetteers([catalogue], for: .nameType)
 
-// Persist a gazetteer to disk
-func saveGazetteer(_ dictionary: [String: [String]], to url: URL) throws {
-    try NLGazetteer.write(dictionary, language: .english, to: url)
-}
+try NLGazetteer.write(["Product": ["Aurora Hub"]],
+                      language: .english,
+                      to: cacheFolder.appendingPathComponent("products.gazetteer"))
 ```
 
-## NLTagger with Multiple Schemes
+## One tagger, several schemes
 
-Request multiple tag schemes in a single tagger for efficient processing.
+Load all the schemes you need up front and query them from the same pass.
 
 ```swift
-func analyzeText(_ text: String) {
-    let tagger = NLTagger(tagSchemes: [.lexicalClass, .nameType, .lemma])
-    tagger.string = text
-
-    let range = text.startIndex..<text.endIndex
-    let options: NLTagger.Options = [.omitWhitespace, .omitPunctuation, .joinNames]
-
-    tagger.enumerateTags(in: range, unit: .word, scheme: .nameTypeOrLexicalClass,
-                         options: options) { tag, tokenRange in
-        let word = String(text[tokenRange])
-        let (lemmaTag, _) = tagger.tag(at: tokenRange.lowerBound,
-                                        unit: .word, scheme: .lemma)
-        let lemma = lemmaTag?.rawValue ?? word
-        print("\(word) -> tag: \(tag?.rawValue ?? "?"), lemma: \(lemma)")
-        return true
-    }
+let multi = NLTagger(tagSchemes: [.lexicalClass, .nameType, .lemma])
+multi.string = note
+multi.enumerateTags(in: note.startIndex..<note.endIndex,
+                    unit: .word,
+                    scheme: .nameTypeOrLexicalClass,
+                    options: [.omitPunctuation, .omitWhitespace, .joinNames]) { kind, span in
+    let (root, _) = multi.tag(at: span.lowerBound, unit: .word, scheme: .lemma)
+    rows.append((String(note[span]), kind?.rawValue ?? "?", root?.rawValue))
+    return true
 }
 ```
 
-## Translation with Replacement Action
+## Translating text in place
 
-Replace the source text in-place after translation using the replacement action.
+With a `replacementAction`, the system sheet offers a Replace button that
+hands you the translated string.
 
 ```swift
-import SwiftUI
-import Translation
-
-struct EditableTranslationView: View {
-    @State private var text = "Hello, how are you?"
-    @State private var showTranslation = false
+struct DraftEditor: View {
+    @State private var draft = ""
+    @State private var translating = false
 
     var body: some View {
-        TextEditor(text: $text)
-            .toolbar {
-                Button("Translate") { showTranslation = true }
+        TextEditor(text: $draft)
+            .toolbar { Button("Translate") { translating = true } }
+            .translationPresentation(isPresented: $translating, text: draft) { translated in
+                draft = translated
             }
-            .translationPresentation(
-                isPresented: $showTranslation,
-                text: text,
-                replacementAction: { translated in
-                    text = translated
-                }
-            )
     }
 }
 ```
 
-## Translation Session Strategies
+## Choosing a translation strategy
 
-Control whether translations prioritize quality or speed. Strategy selection
-requires iOS 26.4+ / macOS 26.4+. Translation content is processed on device;
-`.highFidelity` uses Apple Intelligence models when available, and
-`.lowLatency` uses traditional models.
+Requires iOS 26.4 or macOS 26.4. Translation always runs on the device.
+`.highFidelity` prefers the Apple Intelligence translation models when the
+device has them; `.lowLatency` uses the classic translation models. Neither
+sends text to a server.
 
 ```swift
-import Translation
-
-// High fidelity: more fluent translations when Apple Intelligence is available
-let highQualityConfig = TranslationSession.Configuration(
-    source: Locale.Language(identifier: "en"),
-    target: Locale.Language(identifier: "ja"),
-    preferredStrategy: .highFidelity
-)
-
-// Low latency: faster traditional translation models
-let fastConfig = TranslationSession.Configuration(
-    source: Locale.Language(identifier: "en"),
-    target: Locale.Language(identifier: "ja"),
-    preferredStrategy: .lowLatency
-)
+if #available(iOS 26.4, macOS 26.4, *) {
+    request = TranslationSession.Configuration(
+        source: Locale.Language(identifier: "fr"),
+        target: Locale.Language(identifier: "en"),
+        preferredStrategy: .lowLatency
+    )
+}
 ```
 
-### Preparing a Translation Session
+## Getting a session ready
 
-Pre-download models before translating to avoid UI delays.
+Download models before the user is waiting on a result:
 
 ```swift
-.translationTask(configuration) { session in
-    do {
-        try await session.prepareTranslation()
-        // Models are now ready, translate without delay
-        let response = try await session.translate(sourceText)
-        await MainActor.run {
-            translatedText = response.targetText
-        }
-    } catch {
-        // Handle download refusal, cancellation, or unsupported language pairs.
+struct PhrasebookScreen: View {
+    @State private var warmUp: TranslationSession.Configuration?
+
+    var body: some View {
+        PhraseList()
+            .onAppear { warmUp = .init(source: .init(identifier: "es"), target: .init(identifier: "en")) }
+            .translationTask(warmUp) { @concurrent session in
+                do {
+                    try await session.prepareTranslation()   // triggers any download now
+                } catch {
+                    // declined download, cancellation, or an unsupported pair
+                }
+            }
     }
 }
 ```
 
-For non-UI translation, initialize `TranslationSession(installedSource:target:)`
-only after the source and target languages are installed; this initializer
-throws when the required languages are unavailable.
+`PhraseList` stands for the app's own content view. The closure is
+`@concurrent` for the same reason as in the main skill: the session is not
+`Sendable` and cannot be used from the main actor.
+
+`TranslationSession(installedSource:target:)` (iOS 26, macOS 26) builds a
+session without any view. The initializer does not throw; the session works
+only with models already on the device, so translating fails when either
+language is missing. Create it only after `LanguageAvailability` reports
+`.installed`; a `.translationTask` session, in contrast, can ask the user to
+download.
 
-## SwiftUI Integration Patterns
+```swift
+@available(iOS 26, macOS 26, *)
+func quietSession(from source: Locale.Language, to target: Locale.Language) async -> TranslationSession? {
+    let state = await LanguageAvailability().status(from: source, to: target)
+    guard state == .installed else { return nil }
+    return TranslationSession(installedSource: source, target: target)
+}
+```
 
-### Language Analysis View
+## A live analysis panel in SwiftUI
 
 ```swift
-import SwiftUI
 import NaturalLanguage
+import Observation
+import SwiftUI
 
 @Observable
 @MainActor
-final class TextAnalyzer {
-    var tokens: [String] = []
-    var detectedLanguage: String = ""
-    var sentimentLabel: String = ""
-
-    func analyze(_ text: String) {
-        guard !text.isEmpty else { return }
-
-        // Tokenize
-        let tokenizer = NLTokenizer(unit: .word)
-        tokenizer.string = text
-        tokens = tokenizer.tokens(for: text.startIndex..<text.endIndex)
-            .map { String(text[$0]) }
-
-        // Language
-        detectedLanguage = NLLanguageRecognizer.dominantLanguage(for: text)?
-            .rawValue ?? "Unknown"
-
-        // Sentiment
-        let tagger = NLTagger(tagSchemes: [.sentimentScore])
-        tagger.string = text
-        let (tag, _) = tagger.tag(at: text.startIndex, unit: .paragraph,
-                                   scheme: .sentimentScore)
-        if let score = tag.flatMap({ Double($0.rawValue) }) {
-            sentimentLabel = score > 0.1 ? "Positive" :
-                             score < -0.1 ? "Negative" : "Neutral"
-        }
+final class TextInsights {
+    private(set) var wordCount = 0
+    private(set) var languageCode = "-"
+    private(set) var tone = "neutral"
+
+    func update(for text: String) {
+        let words = NLTokenizer(unit: .word)
+        words.string = text
+        let everything = text.startIndex..<text.endIndex
+        wordCount = words.tokens(for: everything).count
+
+        languageCode = NLLanguageRecognizer.dominantLanguage(for: text)?.rawValue ?? "-"
+
+        let scorer = NLTagger(tagSchemes: [.sentimentScore])
+        scorer.string = text
+        let (moodTag, _) = scorer.tag(at: everything.lowerBound, unit: .paragraph, scheme: .sentimentScore)
+        let value = moodTag.flatMap { Double($0.rawValue) } ?? 0
+        tone = value > 0.1 ? "positive" : value < -0.1 ? "negative" : "neutral"
     }
 }
 
-struct TextAnalysisView: View {
-    @State private var text = ""
-    @State private var analyzer = TextAnalyzer()
+struct InsightsPanel: View {
+    @State private var input = ""
+    @State private var insights = TextInsights()
 
     var body: some View {
         Form {
-            TextField("Enter text", text: $text)
-                .onChange(of: text) { _, newValue in
-                    analyzer.analyze(newValue)
-                }
-            Section("Results") {
-                LabeledContent("Language", value: analyzer.detectedLanguage)
-                LabeledContent("Sentiment", value: analyzer.sentimentLabel)
-                LabeledContent("Words", value: "\(analyzer.tokens.count)")
-            }
+            TextField("Type something", text: $input, axis: .vertical)
+                .onChange(of: input) { _, text in insights.update(for: text) }
+            LabeledContent("Words", value: "\(insights.wordCount)")
+            LabeledContent("Language", value: insights.languageCode)
+            LabeledContent("Tone", value: insights.tone)
         }
     }
 }
 ```
 
-### Requesting NLTagger Assets
+### Tagger assets
 
-Some tag schemes require downloadable assets. Request them before tagging.
+Some schemes need assets that are fetched on demand:
 
 ```swift
-NLTagger.requestAssets(for: .japanese, tagScheme: .nameType) { result, error in
-    switch result {
-    case .available:
-        // Assets loaded, safe to tag Japanese text
-        break
-    case .notAvailable:
-        // Assets not available for this language/scheme
-        break
-    case .error:
-        print("Asset request error: \(error?.localizedDescription ?? "")")
-    @unknown default:
-        break
+NLTagger.requestAssets(for: .korean, tagScheme: .lexicalClass) { outcome, _ in
+    switch outcome {
+    case .available: break       // ready to tag
+    case .notAvailable: break    // this scheme is not offered for the language
+    case .error: break           // retry later
+    @unknown default: break
     }
 }
 ```
 
-## Lemmatization
+## Lemmas for search
 
-Get the base form of words for indexing or search normalization.
+Reducing words to their dictionary form makes "running" and "ran" match
+"run", and "were" match "be". Handy for indexing and search keys.
 
 ```swift
-func lemmatize(_ text: String) -> [String] {
+func lemmas(in text: String) -> [String] {
     let tagger = NLTagger(tagSchemes: [.lemma])
     tagger.string = text
-
-    var lemmas: [String] = []
-    tagger.enumerateTags(
-        in: text.startIndex..<text.endIndex,
-        unit: .word,
-        scheme: .lemma,
-        options: [.omitPunctuation, .omitWhitespace]
-    ) { tag, range in
-        lemmas.append(tag?.rawValue ?? String(text[range]))
+    var roots: [String] = []
+    let fullRange = text.startIndex..<text.endIndex
+    tagger.enumerateTags(in: fullRange,
+                         unit: .word,
+                         scheme: .lemma,
+                         options: [.omitPunctuation, .omitWhitespace]) { tag, span in
+        roots.append(tag?.rawValue ?? String(text[span]))
         return true
     }
-    return lemmas
+    return roots
 }
-// "The cats were running quickly" -> ["the", "cat", "be", "run", "quickly"]
 ```