From c75ee78c8b3988a98805421b1827307d999af5a2 Mon Sep 17 00:00:00 2001
From: debuggerx <dx8917312@163.com>
Date: Mon, 20 Mar 2023 14:47:04 +0800
Subject: [PATCH] AI-223.8617.56.2231.9687552 <debuggerx@debuggerx-e5 Update
 yiiguxing.translation.xml

---
 yiiguxing.translation.xml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/yiiguxing.translation.xml b/yiiguxing.translation.xml
index bf1feb3..c0e9a9b 100644
--- a/yiiguxing.translation.xml
+++ b/yiiguxing.translation.xml
@@ -4,6 +4,7 @@
   </component>
   <component name="Translation.States">
     <histories>
+      <item value="Retrieve the entries of the process environment. The result is an [Iterable] of strings, where each string represents an environment entry. Environment entries should be strings containing a non-empty name and a value separated by a '=' character. The name does not contain a '=' character, so the name is everything up to the first '=' character. Values are everything after the first '=' character. A value may contain further '=' characters, and it may be empty. Returns an [OSError] if retrieving the environment fails." />
       <item value="Creates a new repeating timer. The [callback] is invoked repeatedly with [duration] intervals until canceled with the [cancel] function. The exact timing depends on the underlying timer implementation. No more than `n` callbacks will be made in `duration n` time, but the time between two consecutive callbacks can be shorter and longer than `duration`. In particular, an implementation may schedule the next callback, e.g., a `duration` after either when the previous callback ended, when the previous callback started, or when the previous callback was scheduled for - even if the actual callback was delayed." />
       <item value="Creates a new timer. The [callback] function is invoked after the given [duration]. Example: ```dart final timer = Timer(const Duration(seconds: 5), () =&gt; print('Timer finished')); Outputs after 5 seconds: &quot;Timer finished&quot;. ```" />
       <item value="A countdown timer that can be configured to fire once or repeatedly. The timer counts down from the specified duration to 0. When the timer reaches 0, the timer invokes the specified callback function. Use a periodic timer to repeatedly count down the same interval. A negative duration is treated the same as a duration of 0. If the duration is statically known to be 0, consider using [run]. Frequently the duration is either a constant or computed as in the following example (taking advantage of the multiplication operator of the [Duration] class): ```dart void main() { scheduleTimeout(5 1000); 5 seconds. } Timer scheduleTimeout([int milliseconds = 10000]) =&gt; Timer(Duration(milliseconds: milliseconds), handleTimeout); void handleTimeout() { callback function Do some work. } ``` Note: If Dart code using [Timer] is compiled to JavaScript, the finest granularity available in the browser is 4 milliseconds. See also: [Stopwatch] for measuring elapsed time." />
@@ -53,12 +54,11 @@
       <item value="The optional argument [shared] specifies whether additional `HttpServer` objects can bind to the same combination of `address`, `port` and `v6Only`. If `shared` is `true` and more `HttpServer`s from this isolate or other isolates are bound to the port, then the incoming connections will be distributed among all the bound `HttpServer`s. Connections can be distributed over multiple isolates this way." />
       <item value="Looks up the addresses of a host. If [type] is [InternetAddressType.any], it will lookup both IP version 4 (IPv4) and IP version 6 (IPv6) addresses. If [type] is either [InternetAddressType.IPv4] or [InternetAddressType.IPv6] it will only lookup addresses of the specified type. The order of the list can, and most likely will, change over time." />
       <item value="Handles errors emitted by this [Future]. This is the asynchronous equivalent of a &quot;catch&quot; block. Returns a new [Future] that will be completed with either the result of this future or the result of calling the `onError` callback. If this future completes with a value, the returned future completes with the same value. If this future completes with an error, then [test] is first called with the error value. If `test` returns false, the exception is not handled by this `catchError`, and the returned future completes with the same error and stack trace as this future. If `test` returns `true`, [onError] is called with the error and possibly stack trace, and the returned future is completed with the result of this call in exactly the same way as for [then]'s `onError`. If `test` is omitted, it defaults to a function that always returns true. The `test` function should not throw, but if it does, it is handled as if the `onError` function had thrown. Note that futures don't delay reporting of errors until listeners are added. If the first `catchError` (or `then`) call happens after this future has completed with an error then the error is reported as unhandled error. See the description on [Future]. Example: ```dart Future.delayed( const Duration(seconds: 1), () =&gt; throw 401, ).then((value) { throw 'Unreachable'; }).catchError((err) { print('Error: err'); Prints 401. }, test: (error) { return error is int &amp;&amp; error &gt;= 400; }); ``` The `Function` below stands for one of two types: - (dynamic) -&gt; FutureOr&lt;T&gt; - (dynamic, StackTrace) -&gt; FutureOr&lt;T&gt; Given that there is a `test` function that is usually used to do an `is` check, we should also expect functions that take a specific argument." />
-      <item value="If `test` returns `true`, [onError] is called with the error and possibly stack trace, and the returned future is completed with the result of this call in exactly the same way as for [then]'s `onError`." />
     </histories>
     <option name="languageScores">
       <map>
-        <entry key="CHINESE" value="59" />
-        <entry key="ENGLISH" value="60" />
+        <entry key="CHINESE" value="60" />
+        <entry key="ENGLISH" value="61" />
       </map>
     </option>
   </component>