Skip to content
Back to search

reactor-app

Create WinUI 3 desktop applications using the Reactor framework — a React-inspired declarative C# projection over WinUI 3. No XAML, no data binding, no templates. This file is the legacy single-file skill — prefer the `reactor` plugin under `plugins/reactor/` (or `agentkit/plugins/reactor/` in the NuGet) for a more efficient skill-loading experience.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/unoplatform/Uno.microsoft-ui-reactor with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/unoplatform/Uno.microsoft-ui-reactor'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/unoplatform--uno-microsoft-ui-reactor/badge.svg)](/listings/unoplatform--uno-microsoft-ui-reactor)

HTML

<a href="/listings/unoplatform--uno-microsoft-ui-reactor"><img src="/api/listings/unoplatform--uno-microsoft-ui-reactor/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Reactor ships the public preview package [`Microsoft.UI.Reactor`](https://www.nuget.org/packages/Microsoft.UI.Reactor) on NuGet.org; see the [NuGet page](https://www.nuget.org/packages/Microsoft.UI.Reactor) or [GitHub Releases](https://github.com/microsoft/microsoft-ui-reactor/releases) for the current version. The project templates ship in the official Windows App SDK `dotnet new` pack, so building an app needs no source checkout:

# `winapp` is the Windows App SDK CLI; `winapp new` installs the template pack
# on demand, so there's no separate install step and no version to pin.
winget install Microsoft.WinAppCli
winapp new -t reactor -n MyApp
cd MyApp
dotnet run

Scaffolded apps are packaged (single-project MSIX), so `dotnet run` launches them with full package identity — the F5 equivalent. `reactor-mvu`, `reactor-navview`, and `reactor-tabview` start from richer shells (`winapp new --list` prints them all). Requires Developer Mode (Settings → System → For developers).

Prefer plain .NET tooling? `dotnet new install Microsoft.WindowsAppSDK.WinUI.CSharp.Templates::<version>` followed by `dotnet new reactor -n MyApp` does the same thing. The pack is prerelease-only today and `dotnet new install` resolves stable versions unless you pin one explicitly, which is the step `winapp new` removes.

Contributing to Reactor itself

git clone https://github.com/microsoft/microsoft-ui-reactor.git
cd microsoft-ui-reactor

# calling the bootstrap system under the correct PowerShell version you're on
& (Get-Process -Id $PID).Path -ExecutionPolicy Bypass -File .\bootstrap.ps1

dotnet new reactor -n MyApp
cd MyApp
dotnet run -p:Platform=x64

> ⚠️ **Clone to a short path**: Clone into a short root directory such as > `C:\src\` (e.g. `C:\src\microsoft-ui-reactor`), not a deeply nested or > OneDrive-synced folder. The Windows App SDK's XAML and resource compilers are > 32-bit tools with no long-path support, so a long checkout path can push a > project's generated `obj`/`bin` output past the Windows 260-character > `MAX_PATH` limit and break the build (`MSB3073` / `PRI210`) — most often on > ARM64 dev boxes, where those tools run under emulation. See > [#678](https://github.com/microsoft/microsoft-ui-reactor/issues/678).

> ⚠️ **Platform flag required**: Always build with an explicit platform: > `dotnet build -p:Platform=x64` (or `ARM64`). Omitting `-p:Platform=...` > causes `WindowsAppSDKSelfContained` errors. This applies to `dotnet build`, > `dotnet run`, and `mur check` invocations alike.

`bootstrap.ps1` packs `mur` as a `dotnet tool` global install (cross-shell PATH, no per-arch `$env:Path` edits), packs local framework snapshots into `local-nupkgs/`, installs the Windows App SDK `dotnet new` template pack via the Windows App SDK CLI (`winapp new --list`, which provides `dotnet new reactor`), and installs the Reactor agent plugin under `~/.claude/plugins/reactor`. Apps created by the template reference the public `Microsoft.UI.Reactor` package from NuGet.org by default; pass `--reactor-version 0.0.0-local` when you intentionally want a scaffolded app to consume the local source-built package instead. To hold the template pack at a known-good version, run `./bootstrap.ps1 -WinAppSdkTemplatesVersion <version>`. The optional `Microsoft.UI.Reactor.Advanced` and `Microsoft.UI.Reactor.Devtools` sibling packages are version-matched to the framework package when published. Re-run `bootstrap.ps1` (or `mur upgrade` for a lighter refresh) after `git pull` when you want updated CLI/plugin bits. Verify a working developer install with `mur doctor`.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 600 lines
  1. ---
  2. name: reactor-app
  3. description: >
  4. Create WinUI 3 desktop applications using the Reactor framework — a React-inspired
  5. declarative C# projection over WinUI 3. No XAML, no data binding, no templates.
  6. This file is the legacy single-file skill — prefer the `reactor` plugin under
  7. `plugins/reactor/` (or `agentkit/plugins/reactor/` in the NuGet) for a more
  8. efficient skill-loading experience.
  9. ---
  10. # Reactor — Getting Started
  11. > **Prefer the plugin.** This file is preserved for environments that don't
  12. > support the Copilot CLI / Claude plugin loading model. If you have a plugin
  13. > SDK available, install / load the `reactor` plugin (under
  14. > `plugins/reactor/` in source, or `agentkit/plugins/reactor/` in the NuGet).
  15. > The plugin splits this content into focused per-skill files and is materially
  16. > cheaper to load than this monolith.
  17. Reactor is a **React-inspired functional projection for WinUI 3**. You write
  18. functions that return lightweight element descriptions; a reconciler diffs
  19. old vs new trees and patches real WinUI controls. State changes trigger
  20. re-renders automatically. No XAML. No data binding. No ViewModels.
  21. ## Which mode are you in? (read this first)
  22. Reactor ships as a NuGet package — apps reference it as
  23. `<PackageReference Include="Microsoft.UI.Reactor" Version="…" />` (or
  24. `#:package Microsoft.UI.Reactor@…` for single-file). The package carries
  25. the framework, the analyzers, and an **agent kit** (signatures index +
  26. this SKILL.md). Two paths:
  27. | Mode | How to detect | Bootstrap |
  28. |---|---|---|
  29. | **Selfhost** — you're in a Reactor source clone (`src/Reactor/Reactor.csproj` exists) | The repo's `local-nupkgs/` folder is the package source — see `nuget.config` at repo root. | Build `mur` once, then **`mur pack-local`** to populate `local-nupkgs/Microsoft.UI.Reactor.0.0.0-local.nupkg`. Re-run after framework changes. |
  30. | **Consumer** — you're in an app that depends on Microsoft.UI.Reactor | No `src/Reactor/` next to your project. | Nothing extra — the package already carries the analyzers and agent kit. If `mur` is on PATH, `mur --skill` and `mur --api` print the embedded docs. Otherwise read `<package-cache>/microsoft.ui.reactor/<version>/agentkit/`. |
  31. If you're in selfhost and `local-nupkgs/` is empty, restore will fail with
  32. "package Microsoft.UI.Reactor 0.0.0-local was not found." Run `mur pack-local`
  33. to fix it.
  34. ### Bootstrap (selfhost, fresh clone)
  35. ```powershell
  36. # Build the CLI; on first build the SignaturesGen project also writes
  37. # skills/reactor.api.txt as part of its AfterBuild target.
  38. dotnet build src/Reactor.Cli -p:Platform=ARM64
  39. # `mur` mirrors itself to <repo>/bin/<arch>/. Add that to PATH or invoke directly.
  40. .\bin\arm64\mur.exe pack-local
  41. ```
  42. After this, any project under the clone resolves
  43. `Microsoft.UI.Reactor 0.0.0-local` from `local-nupkgs/` automatically (the
  44. repo-level `nuget.config` configures it). A consumer **outside** the clone
  45. needs a project-local `nuget.config` pointing at the absolute path of
  46. `<repo>/local-nupkgs/`.
  47. ## Where to find docs (`mur --skill`, `mur --api`)
  48. The `mur` CLI ships these embedded — works from any directory:
  49. | Command | What it prints | Source |
  50. |---|---|---|
  51. | `mur --skill` | This SKILL.md | embedded in `mur` |
  52. | `mur --api` | The signatures index (≈70K tokens: every factory/modifier/hook/Theme token/enum, plus ctors/properties/methods/events on every public type — including static classes like `ControlRegistry` and `ReactorApp`) | embedded in `mur` |
  53. | `mur --regen-api` | Rebuilds `skills/reactor.api.txt` from a freshly-built `Reactor.dll` (selfhost only) | rebuilds `tools/Reactor.SignaturesGen` |
  54. | `mur check <path>` | **Is** the build (same exit code as `dotnet build`); adds one-line diagnostics with skill pointers for known REACTOR_* IDs and `→ try:` did-you-mean suggestions | wraps MSBuild |
  55. A consumer who doesn't have `mur` can read the same files directly from the
  56. NuGet cache:
  57. ```
  58. %USERPROFILE%\.nuget\packages\microsoft.ui.reactor\<version>\agentkit\
  59. ├─ SKILL.md ← this file
  60. ├─ reactor.api.txt ← signatures index
  61. └─ skills\
  62. ├─ async.md, design.md, commanding.md, navigation.md, forms.md,
  63. │ input.md, charts.md, dsl-reference.md, devtools.md, perf-tips.md
  64. └─ recipes\
  65. ├─ index.md ← intent → recipe map
  66. └─ <name>.cs ← paste-ready single-file programs
  67. ```
  68. When SKILL.md or a recipe references `skills/foo.md`, a consumer agent
  69. reads it from `agentkit/skills/foo.md` in the package cache. Selfhost
  70. agents read it from `<repo>/skills/foo.md`.
  71. ## API signatures index — load this before grepping source
  72. [`skills/reactor.api.txt`](skills/reactor.api.txt) is a generated, alphabetized
  73. flat list of every public Factory, Modifier, Hook, Theme token (with WinUI
  74. resource key), and enum in Reactor. **Load this when you need to confirm a
  75. signature.** It replaces grepping `src/Reactor/Elements/*.cs` and walking the
  76. sub-skills' tables.
  77. - **Local / selfhost:** the file is committed at `skills/reactor.api.txt`.
  78. Run `mur --api` to print it. Run `mur --regen-api` after framework changes.
  79. - **NuGet consumer:** the same file ships in the package at
  80. `<package-cache>/microsoft.ui.reactor/<version>/agentkit/reactor.api.txt`
  81. (typically `%USERPROFILE%\.nuget\packages\microsoft.ui.reactor\<version>\agentkit\reactor.api.txt`).
  82. If `mur` is on PATH, `mur --api` prints the embedded copy.
  83. ## Recipes — paste-ready snippets indexed by intent
  84. [`skills/recipes/`](skills/recipes/) holds compilable single-file recipes for
  85. the most common Reactor patterns. **Load a recipe instead of synthesizing
  86. from skill prose.** See [`skills/recipes/index.md`](skills/recipes/index.md)
  87. for the intent → recipe map. Available today: list-add-delete, sidebar-nav,
  88. form-with-validation, async-fetch-list, themed-card, canvas-positioning,
  89. named-styles, calendar-multiselect.
  90. ## Wrapping native / third-party controls (source generator)
  91. Need a control Reactor has no built-in factory for (a vendor control or your own
  92. custom `Control`)? Annotate an empty partial record and the
  93. `[GenerateReactorWrapper]` source generator emits the element, descriptor,
  94. registration, and a factory named after the control — no hand-written wrapper:
  95. ```csharp
  96. using Microsoft.UI.Reactor.Wrappers;
  97. [GenerateReactorWrapper(typeof(Acme.Controls.RatingDial))]
  98. public partial record RatingDialElement; // → using static …RatingDialElement; RatingDial(value: …, onValueChanged: …)
  99. ```
  100. Full guidance — auto-inference, the `[Wrap*]` annotation cheat-sheet, imperative
  101. lifecycle, diagnostics, and a gallery of worked examples — is in the
  102. `reactor-wrapping` skill (`plugins/reactor/skills/reactor-wrapping/`, or
  103. `agentkit/plugins/reactor/skills/reactor-wrapping/` in the nupkg). Spec:
  104. `docs/specs/058-control-wrapper-generator.md`.
  105. ## `mur check` — fast feedback with skill pointers
  106. **`mur check` is the build, not a separate check step.** It runs `dotnet build`
  107. under the hood and returns the same exit code. When `mur check` exits 0, the
  108. build is green — **do not re-run `dotnet build` to confirm**. They're the same
  109. compilation; a redundant `dotnet build` afterwards is wasted work.
  110. Two enrichments over raw `dotnet build`:
  111. 1. **Skill pointers** for known `REACTOR_*` IDs.
  112. 2. **Did-you-mean `→ try:` suggestions** for unknown identifiers, computed against
  113. the live Reactor surface for the exact diagnostic.
  114. ```
  115. C:\path\Program.cs:15:23 W REACTOR_DSL_001 Element produced by Select(...)… → SKILL.md gotcha #6 (.WithKey on dynamic list items)
  116. C:\path\Program.cs:34:16 E CS1061 'ButtonElement' does not contain a definition for 'OnClick' → try: Button(label, onClick: ...) // [factory has Action onClick parameter]
  117. ```
  118. `<path>` defaults to `.` and accepts a `.csproj` or directory. Single-file
  119. `.cs` builds work but **don't load analyzers** — for analyzer coverage,
  120. use a `.csproj`.
  121. **Trust `→ try:` suggestions directly.** Use the suggested name verbatim in your
  122. next edit; don't grep adjacent or sibling names to second-guess it. The
  123. suggestion has been computed against the actual Reactor surface for this exact
  124. diagnostic. If wrong, the next `mur check` will tell you — that self-correcting
  125. loop is cheaper than manual verification.
  126. **Don't introspect via `[System.Reflection]`** to enumerate Reactor types or
  127. members — the skill files plus `mur check`'s did-you-mean suggestions plus
  128. `skills/reactor.api.txt` cover the surface.
  129. Workflow modes (Phase-2 ranker):
  130. - `mur check` — iteration mode (default). A ranker suppresses cosmetic noise
  131. (CS1591 XML doc, CS0168 unused-var, IDE0xxx style, NuGet restore chatter)
  132. mid-iteration so the real blocker doesn't scroll off attention. **When this
  133. exits 0, you are done** — the build is green.
  134. - `mur check --final` — optional pre-merge sweep. Emits the cosmetic
  135. diagnostics suppressed during iteration (XML doc, unused locals, style
  136. hints, nullable warnings, transient restore noise). For human code review
  137. or a CI ship-readiness gate; **not** a task-completion requirement and
  138. skipping it is fine.
  139. - `mur check -- <msbuild args>` — anything after a bare `--` is forwarded
  140. verbatim to `dotnet build` (override platform, config, restore, verbosity).
  141. ## Sub-skills — load when the task calls for them
  142. | Skill | When to load |
  143. |---|---|
  144. | [`skills/async.md`](skills/async.md) | Fetching data, caching, pagination, optimistic writes. `UseResource`, `UseMutation`, `UseInfiniteResource`, `Pending`. |
  145. | [`skills/design.md`](skills/design.md) | Any visual-styling work. Windows 11 design rules — theme tokens, High Contrast, typography, 4px grid, acrylic surfaces, accessibility. |
  146. | [`skills/commanding.md`](skills/commanding.md) | Actions that appear in multiple surfaces (menu + toolbar), need keyboard shortcuts, or need `CanExecute`. `Command`, `StandardCommand`, `UseCommand`, `CommandHost`. |
  147. | [`skills/devtools.md`](skills/devtools.md) | Drive a running app via `mur devtools` — screenshot, inspect visual tree, click/type/scroll, read hook state. Load when diagnosing visible bugs (layout, contrast) or verifying a change landed. |
  148. | [`skills/navigation.md`](skills/navigation.md) | Multi-page apps, sidebar/tab navigation, routes, deep linking, page transitions, caching. `UseNavigation`, `NavigationHost`, `NavigationView`, `TabView`. |
  149. | [`skills/forms.md`](skills/forms.md) | Data-entry screens, validation, masked/formatted input. `UseValidationContext`, `FormField`, `MaskEngine`, `InputFormatter`. |
  150. | [`skills/input.md`](skills/input.md) | Gestures, pointer events, drag-and-drop, focus management. `OnPan`, `OnPinch`, `OnRotate`, `OnDragStarting`, `UseElementFocus`. |
  151. | [`skills/charts.md`](skills/charts.md) | Data visualization — choosing a chart type (incl. donut, `TreeChart`, `ForceGraph`), the chart DSL, the `LabelView` / `XTickLabelView` / `YTickLabelView` extension points for icon-plus-text and rich labels, plus the visualization-best-practices rules to refuse to break. |
  152. | [`skills/dsl-reference.md`](skills/dsl-reference.md) | Look up signatures — every factory, modifier, and enum in the DSL. |
  153. ## Project Setup
  154. ### .csproj (copy exactly)
  155. ```xml
  156. <Project Sdk="Microsoft.NET.Sdk">
  157. <PropertyGroup>
  158. <OutputType>WinExe</OutputType>
  159. <TargetFramework>net10.0-windows10.0.22621.0</TargetFramework>
  160. <Platforms>x64;ARM64</Platforms>
  161. <ImplicitUsings>enable</ImplicitUsings>
  162. <Nullable>enable</Nullable>
  163. <UseWinUI>true</UseWinUI>
  164. <WindowsPackageType>None</WindowsPackageType>
  165. </PropertyGroup>
  166. <ItemGroup>
  167. <PackageReference Include="Microsoft.UI.Reactor" Version="0.0.0-local" />
  168. <PackageReference Include="Microsoft.WindowsAppSDK" Version="2.2.0" />
  169. </ItemGroup>
  170. </Project>
  171. ```
  172. In selfhost the version is `0.0.0-local` (produced by `mur pack-local` —
  173. see "Which mode are you in?" above). Outside the source clone, replace it
  174. with whatever Microsoft.UI.Reactor version you depend on.
  175. **After `dotnet new reactor -n <Name>`, the entry point is `App.cs`**
  176. (entry point + initial component), next to `<Name>.csproj`. The template
  177. also emits packaging scaffolding you normally don't touch:
  178. `Package.appxmanifest`, `app.manifest`, `Assets/`, and
  179. `Properties/launchSettings.json` + `Properties/PublishProfiles/`. There is no
  180. `Program.cs` and no `GlobalUsings.cs` — modify `App.cs` in place. `App.cs` has
  181. its own `using` directives at the top — the canonical set (System + Reactor +
  182. Reactor.Core + Reactor.Layout + Xaml + Xaml.Controls + static
  183. Factories) — which is the only place you add new namespaces (e.g. `using System.Linq;` when
  184. you reach for `.Select(...)`). Don't probe the `.csproj` after
  185. scaffolding unless you're adding a `PackageReference` or changing a
  186. property — `Restore succeeded.` in the scaffold stdout is the only
  187. confirmation you need.
  188. Apps from `dotnet new reactor` are **packaged** (single-project MSIX), so
  189. `dotnet run` launches them with package identity and needs Developer Mode on.
  190. The other short names are `reactor-mvu`, `reactor-navview`, and
  191. `reactor-tabview`.
  192. **Verify your edits with `mur check`** before declaring done. From the
  193. project directory: `mur check` (no arguments) runs `dotnet build` and
  194. emits one compressed line per diagnostic with a `→ try:` suggestion
  195. when the engine recognizes the mistake; `mur check --final` is the
  196. explicit "I am done iterating" sweep that emits the full diagnostic
  197. set including suppressed iteration-mode warnings. For anything more
  198. involved than the build/fix loop — strict-mode failures, custom
  199. diagnostic gating, MSBuild passthrough flags — load the
  200. `reactor-build-and-check` skill.
  201. ### nuget.config (selfhost only — sibling of the .csproj)
  202. If your .csproj lives **outside** the Reactor clone, add a `nuget.config`
  203. next to it pointing at the clone's `local-nupkgs/` (absolute path):
  204. ```xml
  205. <?xml version="1.0" encoding="utf-8"?>
  206. <configuration>
  207. <packageSources>
  208. <add key="reactor-local" value="C:\path\to\reactor2\local-nupkgs" />
  209. <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
  210. </packageSources>
  211. </configuration>
  212. ```
  213. Inside the clone you don't need this — the repo-level `nuget.config`
  214. already configures the feed.
  215. For a **hand-authored** csproj like the one above, `WindowsPackageType` MUST be
  216. `None` (unpackaged, no App.xaml) and `UseWinUI` MUST be `true`. Apps scaffolded
  217. by `dotnet new reactor` are packaged instead and omit `WindowsPackageType`
  218. entirely — leave their packaging properties alone. Either way: no XAML files of
  219. any kind.
  220. ### Required imports
  221. ```csharp
  222. using Microsoft.UI.Reactor;
  223. using Microsoft.UI.Reactor.Core;
  224. using Microsoft.UI.Reactor.Layout; // FlexDirection, FlexJustify, ... (if using Flex)
  225. using Microsoft.UI.Xaml; // Thickness, HorizontalAlignment, VerticalAlignment
  226. using Microsoft.UI.Xaml.Controls; // Orientation, InfoBarSeverity, etc.
  227. using static Microsoft.UI.Reactor.Factories; // TextBlock(), Button(), VStack() bare calls
  228. ```
  229. ### App entry point
  230. ```csharp
  231. // Component root
  232. ReactorApp.Run<MyRoot>("Title", width: 1024, height: 768);
  233. // Inline render function
  234. ReactorApp.Run("Title", ctx =>
  235. {
  236. var (msg, setMsg) = ctx.UseState("Hello!");
  237. return VStack(TextBlock(msg), Button("Change", () => setMsg("Changed!")));
  238. });
  239. ```
  240. ## Components
  241. ### Class component (primary pattern)
  242. ```csharp
  243. class Counter : Component
  244. {
  245. public override Element Render()
  246. {
  247. var (count, setCount) = UseState(0);
  248. return VStack(
  249. TextBlock($"Count: {count}"),
  250. Button("+1", () => setCount(count + 1)));
  251. }
  252. }
  253. ```
  254. ### Function component (inline, small reusable pieces)
  255. ```csharp
  256. var toggle = Memo(ctx =>
  257. {
  258. var (on, setOn) = ctx.UseState(false);
  259. return ToggleSwitch(on, setOn);
  260. });
  261. ```
  262. ### Embedding & props
  263. ```csharp
  264. // Embed:
  265. VStack(Component<MyWidget>(), Component<AnotherWidget>())
  266. // Typed props — use records for free structural equality:
  267. record UserCardProps(string Name, string Role);
  268. class UserCard : Component<UserCardProps> { ... }
  269. Component<UserCard, UserCardProps>(new UserCardProps("Alice", "Admin"))
  270. ```
  271. ### Memoized function component
  272. ```csharp
  273. Memo(ctx => TextBlock("Stable")) // render once + own state
  274. Memo(ctx => TextBlock($"Hi, {name}"), name) // re-render when deps change
  275. ```
  276. Propless `Component` skips parent-triggered re-renders by default.
  277. `Component<TProps>` skips when `Equals(oldProps, newProps)`.
  278. ## Hooks
  279. Rules: same order every render (no hooks in `if`/`for`), only from `Render()`
  280. or function-component body.
  281. | Hook | Returns | Use for |
  282. |---|---|---|
  283. | `UseState<T>(initial)` | `(T, Action<T>)` | Primary state |
  284. | `UseReducer<T>(initial)` | `(T, Action<Func<T,T>>)` | State derived from previous (lists) |
  285. | `UseEffect(action, deps)` | — | Side effects + cleanup |
  286. | `UseMemo<T>(factory, deps)` | `T` | Memoized computation |
  287. | `UseCallback(action, deps)` | `Action` | Stable callback reference |
  288. | `UseRef<T>(initial)` | `Ref<T>` | Mutable ref across renders |
  289. | `UseObservable<T>(source)` | `T` | Track `INotifyPropertyChanged` |
  290. | `UseCollection<T>(coll)` | `IReadOnlyList<T>` | Track `ObservableCollection` |
  291. | `UseContext<T>(ctx)` | `T` | Read tree-scoped ambient state |
  292. | `UsePersisted<T>(key, initial)` | `(T, Action<T>)` | State that survives unmount |
  293. | `UseResource<T>`, `UseInfiniteResource`, `UseMutation` | See `skills/async.md` | Async data |
  294. ### UseState / UseReducer
  295. ```csharp
  296. var (count, setCount) = UseState(0);
  297. var (items, updateItems) = UseReducer(new List<Todo>());
  298. // List mutation via UseReducer (UseState with List<T> won't re-render on mutate!):
  299. updateItems(list => [.. list, new Todo("New", false)]);
  300. ```
  301. ### UseEffect
  302. ```csharp
  303. UseEffect(() => { /* mount */ }); // empty deps → once
  304. UseEffect(() => { /* on count change */ }, count);
  305. UseEffect(() =>
  306. {
  307. var timer = new Timer(...);
  308. return () => timer.Dispose(); // cleanup
  309. }, deps);
  310. ```
  311. ### UseContext
  312. ```csharp
  313. public static readonly Context<string> ThemeCtx = new("light");
  314. // Provide:
  315. VStack(...).Provide(ThemeCtx, "dark")
  316. // Consume:
  317. var theme = UseContext(ThemeCtx);
  318. ```
  319. ## DSL — the essentials
  320. For the complete catalog (every factory, modifier, enum) see
  321. [`skills/dsl-reference.md`](skills/dsl-reference.md). The 90% cases:
  322. ```csharp
  323. // Text + layout — prefer FlexRow/FlexColumn for linear layout; they use CSS Flexbox
  324. // semantics (grow/shrink/gap/wrap, justify-content, align-items) so the model matches
  325. // the web. VStack/HStack remain available when you specifically want StackPanel's
  326. // shrink-wrap behavior.
  327. FlexColumn(children...) FlexRow(children...)
  328. VStack(spacing, children...) HStack(spacing, children...)
  329. TextBlock("hi") Heading("Title") SubHeading("Section") Caption("note")
  330. // WinUI 3 type-ramp factories — map 1:1 to TitleTextBlockStyle etc.
  331. Title("Page") Subtitle("Group") Body("paragraph") BodyStrong("bold") BodyLarge("intro")
  332. TitleLarge("Feature") // 40px — primary title on a feature/landing page
  333. Display("Hero") // 68px — hero banner, at most one per page
  334. // Card(child) factory bakes in CardBackground + 1px CardStroke + 8 radius + 16 padding.
  335. Card(child)
  336. Border(child).CornerRadius(8).Background(Theme.CardBackground).Padding(16)
  337. ScrollView(VStack(...)) // modern InteractionTracker-backed; ScrollViewer(...) is the classic control if you need attached props / parallax
  338. Grid(columns: [GridSize.Star(), GridSize.Px(200)],
  339. rows: [GridSize.Auto, GridSize.Star()],
  340. childA.Grid(row: 0, column: 0), childB.Grid(row: 1, column: 1))
  341. TitleBar("App") with { Subtitle = "Home", Content = ..., RightHeader = ... }
  342. // Controls
  343. Button("Click", () => ...) TextBox(value, setValue, placeholder)
  344. CheckBox(isChecked, setChecked) ToggleSwitch(on, setOn)
  345. Slider(v, 0, 100, setV) ComboBox(items, index, setIndex)
  346. // Strings auto-convert to TextBlockElement: VStack("A", "B") works.
  347. ```
  348. ### Conditional rendering
  349. ```csharp
  350. isLoggedIn ? TextBlock($"Hi, {name}") : Button("Log in", onLogin)
  351. VStack(TextBlock("always"), showExtra ? TextBlock("maybe") : null) // null filtered
  352. When(items.Any(), () => TextBlock($"{items.Count} items"))
  353. If(isError, () => InfoBar("Error", msg).Severity(InfoBarSeverity.Error),
  354. () => TextBlock("OK"))
  355. status switch {
  356. Status.Loading => ProgressIndeterminate(),
  357. Status.Error => TextBlock("Oops"),
  358. Status.Success => Component<SuccessView>(),
  359. _ => Empty()
  360. }
  361. ForEach(items, item => TextBlock(item.Name))
  362. // Or LINQ: VStack(items.Select(i => TextBlock(i.Name)).ToArray())
  363. ```
  364. ## Critical gotchas
  365. 1. **Hook order is constant.** No hooks inside `if`/`for`. Call them all
  366. unconditionally; conditionally use the result.
  367. 2. **Type-specific sugar before generic modifiers.**
  368. `TextBlock("Hi").Bold().Margin(10)` ✓ — `.Bold()` needs `TextBlockElement`.
  369. `TextBlock("Hi").Margin(10).Bold()` ✗ — `.Margin()` returns `Element`.
  370. 3. **List mutations use `UseReducer`.** `UseState(new List<T>())` + `list.Add()`
  371. won't re-render — same reference. Use `UseReducer(list => [.. list, item])`.
  372. 4. **Null children are filtered.** `VStack(a, condition ? b : null, c)` is safe.
  373. 5. **Records with `with` for init-only properties.**
  374. `NavigationView(items, content) with { SelectedTag = "home", IsPaneOpen = true }`.
  375. 6. **`.WithKey("id")` on dynamic list items.** Without keys, the reconciler
  376. matches by position and re-mounts everything on insert/reorder.
  377. 7. **Memoize expensive computations.** `UseMemo(() => items.OrderBy(...).ToList(), items)`.
  378. 8. **`.Flex(grow: 1)` is `flex-grow`, not the CSS `flex: 1` shorthand.** Default
  379. basis is `auto` (content size), so a growing child with large intrinsic
  380. content (e.g. `ListView` with many items) overflows the container and Yoga
  381. shrinks every sibling proportionally — heading/buttons/inputs all collapse.
  382. Pass `.Flex(grow: 1, basis: 0)` (matches CSS `flex: 1`) or add
  383. `.Flex(shrink: 0)` to each fixed-size sibling. See `skills/dsl-reference.md`.
  384. ## Starter template
  385. ```csharp
  386. using Microsoft.UI.Reactor;
  387. using Microsoft.UI.Reactor.Core;
  388. using Microsoft.UI.Xaml;
  389. using static Microsoft.UI.Reactor.Factories;
  390. ReactorApp.Run<App>("My App", width: 1200, height: 800);
  391. class App : Component
  392. {
  393. public override Element Render()
  394. {
  395. var (page, setPage) = UseState("Home");
  396. return Grid(
  397. columns: [GridSize.Star()],
  398. rows: [GridSize.Auto, GridSize.Star()],
  399. Border(
  400. HStack(12,
  401. Heading("My App").VAlign(VerticalAlignment.Center),
  402. NavBtn("Home", page, setPage),
  403. NavBtn("Settings", page, setPage))
  404. ).Background("#f0f0f0").Padding(horizontal: 24, vertical: 12).Grid(row: 0),
  405. Border(page switch
  406. {
  407. "Home" => Component<HomePage>(),
  408. "Settings" => Component<SettingsPage>(),
  409. _ => TextBlock("Not found")
  410. }).Padding(24).Grid(row: 1));
  411. }
  412. static Element NavBtn(string label, string current, Action<string> set) =>
  413. Button(label, () => set(label)).IsEnabled(!(label == current));
  414. }
  415. ```
  416. ## Testing
  417. Run the suite that matches what you changed.
  418. ```bash
  419. # Unit tests — fast, no UI window (~3s)
  420. dotnet test tests/Reactor.Tests
  421. # Selfhost tests — real WinUI controls, in-process (~2 min)
  422. dotnet test tests/Reactor.SelfTests
  423. # Packaged selfhost tests — the same fixtures under MSIX package identity (~5 min).
  424. # Needed for anything that reads ms-appx:, Package.Current, MRT, or package identity.
  425. # Requires Developer Mode; fails rather than skips without it.
  426. dotnet test tests/Reactor.PackagedTests -p:Platform=x64
  427. # E2E — cross-process UI Automation via winapp ui (~30s, needs the winapp CLI)
  428. dotnet test tests/Reactor.AppTests --filter "ClassName=Microsoft.UI.Reactor.AppTests.Tests.InteractiveTests"
  429. # Everything (includes the packaged tier, so Developer Mode is required)
  430. dotnet test Reactor.slnx
  431. ```
  432. `samples/Reactor.TestApp` is the interactive demo, not a test runner.
  433. ## Single-file apps with `dotnet run`
  434. For lightweight demos, skip the `.csproj` entirely. Add a file-level header:
  435. ```csharp
  436. #:package Microsoft.UI.Reactor@0.0.0-local
  437. #:package Microsoft.Windows.SDK.BuildTools.WinApp@0.7.0
  438. #:property OutputType=WinExe
  439. #:property TargetFramework=net10.0-windows10.0.22621.0
  440. #:property UseWinUI=true
  441. using Microsoft.UI.Reactor;
  442. using static Microsoft.UI.Reactor.Factories;
  443. ReactorApp.Run("Hello", ctx =>
  444. {
  445. var (count, setCount) = ctx.UseState(0);
  446. return VStack(TextBlock($"Count: {count}"), Button("+1", () => setCount(count + 1)));
  447. });
  448. ```
  449. Run with `dotnet run MyApp.cs` — no architecture flag. This is the header the
  450. [Getting Started guide](https://microsoft.github.io/microsoft-ui-reactor/getting-started/#one-file-no-project)
  451. documents: `Microsoft.Windows.SDK.BuildTools.WinApp` makes `dotnet run` launch
  452. the app packaged, with package identity, which needs Developer Mode. If
  453. Developer Mode is off, or you don't need identity, add
  454. `#:property WindowsPackageType=None` to run it as a plain unpackaged `.exe`.
  455. With neither, the app builds, then dies at startup with `REGDB_E_CLASSNOTREG`.
  456. Either way the app uses the Windows App Runtime installed on the machine. To
  457. bundle it instead, add `#:property WindowsAppSDKSelfContained=true`; that mode
  458. also needs an architecture (`-r win-x64` or `-r win-arm64`), and `-r` alone
  459. bundles nothing.
  460. In selfhost the version is `0.0.0-local` — run `mur pack-local` first if the
  461. package isn't found. Outside the clone, replace the version with the published
  462. release you depend on.
  463. > **Always capture `dotnet run` output.** Build errors exit with code 1.
  464. > Read compiler output, fix, retry. Don't assume success without checking.
  465. > Note: single-file builds **do not load analyzers** — for analyzer
  466. > coverage (`REACTOR_DSL_001`, `REACTOR_HOOKS_*`, etc.), use a `.csproj`.
  467. ## Comparison to React
  468. | React | Reactor |
  469. |---|---|
  470. | `function App() {}` | `class App : Component { Render() }` |
  471. | `useState(0)` | `UseState(0)` |
  472. | `useReducer` | `UseReducer(initial)` — updater is `Func<T,T>` |
  473. | `useEffect(() => {}, [dep])` | `UseEffect(() => {}, dep)` |
  474. | `useMemo(() => val, [dep])` | `UseMemo(() => val, dep)` |
  475. | `<div>` | `FlexColumn() / FlexRow() / Border()` (prefer over `VStack`/`HStack`) |
  476. | `<span>text</span>` | `TextBlock("text")` |
  477. | `<button onClick={fn}>` | `Button("label", fn)` |
  478. | `<input value={v} onChange={fn}>` | `TextBox(v, fn)` |
  479. | `{cond && <X/>}` | `cond ? X() : null` |
  480. | `{items.map(i => <X/>)}` | `items.Select(i => X()).ToArray()` |
  481. | `<Component />` | `Component<MyComponent>()` |
  482. | `createContext` + `useContext` | `Context<T>` + `.Provide()` + `UseContext()` |
  483. | React Query `useQuery` / `useMutation` | `UseResource` / `UseMutation` — see `skills/async.md` |
  484. | `className="..."` | `.Set(el => ...)` for native access |
  485. | `display: flex` / `flex-grow: 1` | `Flex()` / `.Flex(grow: 1)` |
  486. | `style={{margin: 10}}` | `.Margin(10)` |
  487. | JSX | C# calls + `using static Factories` |
README.md · README · 340 lines
  1. # Uno Platform port of Microsoft.UI.Reactor
  2. [Microsoft.UI.Reactor](https://github.com/microsoft/microsoft-ui-reactor) is Microsoft's framework for writing WinUI 3 apps the way React works: you build the UI from components and hooks in C#, with no XAML. Microsoft's version runs only on Windows. [Uno Platform](https://platform.uno/) implements the WinUI API on desktop (Windows, macOS, Linux), WebAssembly, Android and iOS, and its Skia renderer draws every control itself, so it looks the same everywhere. This port runs the same Reactor code on all of those targets. It is experimental, like Reactor itself, and a work in progress.
  3. - **Requirements:** a .NET 10 SDK. For WebAssembly, Android or iOS, [uno-check](https://platform.uno/docs/articles/external/uno.check/doc/using-uno-check.html) installs the workloads and SDKs those targets need; desktop needs none.
  4. - **Start an app:** `dotnet new install Uno.Templates@7.0.0-dev.119`, then `dotnet new unoapp-reactor -n MyApp`, from the command line: Visual Studio's New Project dialog doesn't list this template. Keep the version, or use a later one: a plain `dotnet new install Uno.Templates` installs the stable templates, which don't have `unoapp-reactor` yet. Or add `Reactor` to the `UnoFeatures` list in an existing Uno app's `.csproj`. See the port README's [quick start](src/Reactor.Uno/README.md#quick-start--a-new-app-from-the-template), which also covers a single-file app.
  5. - **Learn Reactor:** Microsoft's [guide](https://microsoft.github.io/microsoft-ui-reactor/) teaches components, hooks and the C# DSL, and that code runs here unchanged. Skip its setup steps (`winapp`, MSIX packaging), which are for Windows; start your app as above. Then check what works on Uno below.
  6. - **What works:** the [feature support table](src/Reactor.Uno/README.md#feature-support-on-uno-skia) for Uno Skia.
  7. - **Windows App SDK:** this package doesn't target it; use Microsoft's [`Microsoft.UI.Reactor`](https://www.nuget.org/packages/Microsoft.UI.Reactor) there.
  8. - **Package:** [`Uno.Microsoft.UI.Reactor`](https://www.nuget.org/packages/Uno.Microsoft.UI.Reactor) on nuget.org. Prerelease `-dev.N` builds are published from the `uno` branch, and stable releases from `release/stable/*` branches.
  9. - **Build this repo:** needs .NET SDK 10.0.400 or later, because the port runs Reactor's source generators while it compiles. `dotnet build Reactor.Uno.slnx -f net10.0-desktop` builds the port and its samples; `cd samples/Uno/ReactorUnoCounter && dotnet run -f net10.0-desktop` runs the counter sample. The other samples and targets are in [samples/Uno](samples/Uno/README.md).
  10. **Issues:** bugs in the Uno port go here; bugs in Reactor itself go to [microsoft/microsoft-ui-reactor](https://github.com/microsoft/microsoft-ui-reactor/issues).
  11. **Branches:** `uno` (the default) holds the port and takes the pull requests; this fork's `main` is unused. Microsoft's latest `main` comes in through a nightly sync PR (`.github/workflows/upstream-sync.yml`), auto-merged when the merge is clean. Which files are ours and which workflows run here is in [MAINTAINING.md](src/Reactor.Uno/MAINTAINING.md).
  12. *Everything below is Microsoft's README, unchanged. It is written for Windows, so on Uno:*
  13. - *Its counter example runs unchanged in a Uno app or a single-file app.*
  14. - *Its "Quick start", "Contributing to Reactor itself", "Live preview" and "Sample apps" sections are Windows-only. Use the links above instead. Hot Reload does work, through Uno: see the port README's [Hot Reload](src/Reactor.Uno/README.md#hot-reload).*
  15. - *In "What's included", Docking, Shell integration, WinForms interop, the Win2D canvas, the in-app DevTools and the Visual Studio preview aren't in the port. The package also ships no analyzers or source generators: Reactor's Roslyn analyzers and localization generator don't run, and `[GenerateReactorWrapper]` on your own controls generates nothing. For the rest, see the [feature support table](src/Reactor.Uno/README.md#feature-support-on-uno-skia).*
  16. ---
  17. <a href="https://github.com/microsoft/microsoft-ui-xaml">
  18. <img src="docs/images/header.png" alt="WinUI hero image"/>
  19. </a>
  20. <h1 align="center">Microsoft.UI.Reactor</h1>
  21. <p align="center">
  22. <strong>A declarative, component-based C# framework for building <a href="https://github.com/microsoft/microsoft-ui-xaml">WinUI 3</a> desktop apps.</strong>
  23. </p>
  24. <p align="center">
  25. <strong>Status:</strong> Experimental · April 2026
  26. </p>
  27. ---
  28. ## What Reactor is — and isn't
  29. Reactor is **not** a new UI platform. It is a new way to *describe* WinUI content. Every control you render is a real WinUI control — `Button`, `TextBox`, `NavigationView`, `TreeView` — just authored differently. Apps built with Reactor interop freely with XAML, MVVM, existing controls, and the rest of the WinUI ecosystem.
  30. What Reactor adds on top of WinUI:
  31. - A virtual element tree and reconciler that diff old vs. new descriptions and patch only what changed on real WinUI controls
  32. - Hooks-based state (`UseState`, `UseEffect`, `UseReducer`, …) co-located with render logic
  33. - A C# DSL that replaces XAML markup with typed factory methods and fluent modifiers
  34. - Higher-level building blocks — flex layout, charting, commanding, navigation, data grid, theming, localization — many of which are candidates to migrate back into WinUI itself
  35. ```csharp
  36. using Microsoft.UI.Reactor;
  37. using Microsoft.UI.Reactor.Core;
  38. using static Microsoft.UI.Reactor.Factories;
  39. ReactorApp.Run<MyApp>("Hello Reactor");
  40. class MyApp : Component
  41. {
  42. public override Element Render()
  43. {
  44. var (count, setCount) = UseState(0);
  45. return VStack(
  46. Heading($"Count: {count}"),
  47. HStack(8,
  48. Button("-", () => setCount(count - 1)),
  49. Button("+", () => setCount(count + 1))
  50. )
  51. );
  52. }
  53. }
  54. ```
  55. No `App.xaml`. No `MainWindow.xaml`. No code-behind. No ViewModels. Just C# with full IntelliSense, refactoring, and compile-time type safety.
  56. ---
  57. ## XAML and MVVM are not going anywhere
  58. WinUI is a powerful native platform, and the XAML + MVVM programming model is a great fit for a large portion of the WinUI user base. Tooling, designer support, templating, data binding, and years of guidance, samples, and third-party controls are built around it. Reactor does **not** try to replace any of that.
  59. What Reactor does target is a specific gap: developers coming from React, SwiftUI, or Jetpack Compose expect co-located state, declarative composition, and type-safe UI construction. Reactor brings those patterns to WinUI without asking anyone to abandon the platform they already ship on. The two models coexist:
  60. - **If you're shipping XAML/MVVM today**, keep shipping XAML/MVVM. The investments we're making in Reactor — improved accessibility APIs, richer theming, better commanding, a stronger data stack — are designed to flow back into WinUI so you benefit too.
  61. - **If you want a functional MVU model** with no XAML and no ViewModels, Reactor is a path to get there on the same runtime, with the same controls, in the same process.
  62. - **If you want both**, you can host Reactor content inside a XAML app, or drop XAML content inside a Reactor app. They share the visual tree.
  63. Many of the experiments in this repo — the charting stack, accessibility validators, commanding, flex layout, theming tokens — are likely to land in WinUI directly, where they'll work for XAML and MVVM users too. Others may continue to ship through Reactor. Either way, **WinUI is the foundation**.
  64. ---
  65. ## Quick start
  66. Reactor ships the public preview package [`Microsoft.UI.Reactor`](https://www.nuget.org/packages/Microsoft.UI.Reactor) on NuGet.org; see the [NuGet page](https://www.nuget.org/packages/Microsoft.UI.Reactor) or [GitHub Releases](https://github.com/microsoft/microsoft-ui-reactor/releases) for the current version. The project templates ship in the official Windows App SDK `dotnet new` pack, so building an app needs no source checkout:
  67. ```powershell
  68. # `winapp` is the Windows App SDK CLI; `winapp new` installs the template pack
  69. # on demand, so there's no separate install step and no version to pin.
  70. winget install Microsoft.WinAppCli
  71. winapp new -t reactor -n MyApp
  72. cd MyApp
  73. dotnet run
  74. ```
  75. Scaffolded apps are packaged (single-project MSIX), so `dotnet run` launches them with full package identity — the F5 equivalent. `reactor-mvu`, `reactor-navview`, and `reactor-tabview` start from richer shells (`winapp new --list` prints them all). Requires Developer Mode (Settings → System → For developers).
  76. Prefer plain .NET tooling? `dotnet new install Microsoft.WindowsAppSDK.WinUI.CSharp.Templates::<version>` followed by `dotnet new reactor -n MyApp` does the same thing. The pack is prerelease-only today and `dotnet new install` resolves stable versions unless you pin one explicitly, which is the step `winapp new` removes.
  77. ### Contributing to Reactor itself
  78. ```powershell
  79. git clone https://github.com/microsoft/microsoft-ui-reactor.git
  80. cd microsoft-ui-reactor
  81. # calling the bootstrap system under the correct PowerShell version you're on
  82. & (Get-Process -Id $PID).Path -ExecutionPolicy Bypass -File .\bootstrap.ps1
  83. dotnet new reactor -n MyApp
  84. cd MyApp
  85. dotnet run -p:Platform=x64
  86. ```
  87. > ⚠️ **Clone to a short path**: Clone into a short root directory such as
  88. > `C:\src\` (e.g. `C:\src\microsoft-ui-reactor`), not a deeply nested or
  89. > OneDrive-synced folder. The Windows App SDK's XAML and resource compilers are
  90. > 32-bit tools with no long-path support, so a long checkout path can push a
  91. > project's generated `obj`/`bin` output past the Windows 260-character
  92. > `MAX_PATH` limit and break the build (`MSB3073` / `PRI210`) — most often on
  93. > ARM64 dev boxes, where those tools run under emulation. See
  94. > [#678](https://github.com/microsoft/microsoft-ui-reactor/issues/678).
  95. > ⚠️ **Platform flag required**: Always build with an explicit platform:
  96. > `dotnet build -p:Platform=x64` (or `ARM64`). Omitting `-p:Platform=...`
  97. > causes `WindowsAppSDKSelfContained` errors. This applies to `dotnet build`,
  98. > `dotnet run`, and `mur check` invocations alike.
  99. `bootstrap.ps1` packs `mur` as a `dotnet tool` global install (cross-shell PATH, no per-arch `$env:Path` edits), packs local framework snapshots into `local-nupkgs/`, installs the Windows App SDK `dotnet new` template pack via the Windows App SDK CLI (`winapp new --list`, which provides `dotnet new reactor`), and installs the Reactor agent plugin under `~/.claude/plugins/reactor`. Apps created by the template reference the public `Microsoft.UI.Reactor` package from NuGet.org by default; pass `--reactor-version 0.0.0-local` when you intentionally want a scaffolded app to consume the local source-built package instead. To hold the template pack at a known-good version, run `./bootstrap.ps1 -WinAppSdkTemplatesVersion <version>`. The optional `Microsoft.UI.Reactor.Advanced` and `Microsoft.UI.Reactor.Devtools` sibling packages are version-matched to the framework package when published. Re-run `bootstrap.ps1` (or `mur upgrade` for a lighter refresh) after `git pull` when you want updated CLI/plugin bits. Verify a working developer install with `mur doctor`.
  100. > **Scaffolding.** Reactor's templates ship in the official Windows App SDK template pack. `winapp new -t reactor` installs that pack on demand and scaffolds in one step; `dotnet new reactor` works too once the pack is installed. The in-repo `Microsoft.UI.Reactor.ProjectTemplates` package that used to provide `dotnet new reactorapp` has been removed; its published versions are deprecated on NuGet.org.
  101. On networks where the public NuGet registry is unreachable, bootstrap detects a recognised package mirror already configured in the user's NuGet.Config, verifies unauthenticated package access, and uses it only for the bootstrap process — including the optional Visual Studio extension build. Contributors on an unrestricted network keep the public defaults, unchanged. Any mirror can be selected explicitly with `-NuGetConfig <path>`; credentials remain in user configuration and are never written to the repository. Package feed URLs must use HTTPS (except loopback development feeds) and cannot embed credentials, query strings, or fragments.
  102. `src/Reactor.Cli` and two samples reference `GitHub.Copilot.SDK`, whose build targets download a native `copilot` CLI from the [github/copilot-cli releases](https://github.com/github/copilot-cli/releases) during a plain `dotnet build` / `dotnet run` / `dotnet test` (checksum-verified against the release's `SHA256SUMS.txt`). If that download is blocked on your network, point it at a mirror of those release assets with `CopilotCliReleaseBaseUrl` (or the `COPILOT_CLI_DOWNLOAD_BASE_URL` environment variable), or supply a pre-downloaded binary with `CopilotCliBinaryPath`. `CopilotSkipCliDownload=true` also gets a blocked build moving, but only for compiling: it omits the native binary that `mur loc translate` and the two Copilot SDK samples start at run time. CI sets it because CI never runs those paths.
  103. Prefer to wire it up by hand? **[Getting Started](https://microsoft.github.io/microsoft-ui-reactor/getting-started/#manual-setup)** has a no-magic walkthrough of the exact `dotnet pack` / `dotnet tool install` / `dotnet new install` calls `bootstrap.ps1` makes, plus the full hello-world → todo → calculator tour.
  104. Release owners: see the [release runbook](docs/contributing/release-runbook.md) before minting a new version tag.
  105. ---
  106. ## What's included
  107. Reactor spans a core framework and a set of higher-level features. Each area below is labeled by its current maturity — *Preview* is the most mature, then *Draft*, then *Early*. **All areas are pre-1.0 and the public API surface may change without notice while the project is labeled experimental.**
  108. | Area | What it does | Maturity |
  109. |---|---|---|
  110. | **Core reconciler** | Virtual element tree, keyed diffing, element pooling, render coalescing, skip-unchanged optimization | Preview |
  111. | **DSL & elements** | Factory methods covering WinUI controls, fluent modifier chains, attached properties | Preview |
  112. | **Hooks & state** | UseState, UseReducer, UseEffect, UseMemo, UseRef, UseCallback, UseContext, UseObservable, UseCollection | Preview |
  113. | **Flex layout** | C# port of facebook/yoga with FlexPanel, 543 ported test fixtures | Preview |
  114. | **Commanding** | Command records bundling label, icon, shortcut, and action; 16 standard commands; focus-scoped accelerators | Preview |
  115. | **Charting (D3)** | Full D3 algorithm port plus declarative chart DSL — line, bar, area, pie, tree, force-directed graphs | Preview |
  116. | **Markdown** | Native md4c parser with `Markdown()` element builder | Preview |
  117. | **Navigation** | Type-safe declarative routing, GPU composition transitions, lifecycle guards, back-stack serialization | Draft |
  118. | **Accessibility** | `AutomationProperties` modifiers (e.g. name, heading level, landmarks, live regions), WCAG 2.1 AA target, compile- and runtime-validation | Draft |
  119. | **Animation** | Compositor-layer transitions, keyframes, stagger, scroll-linked and connected animations | Draft |
  120. | **Theming & styling** | `ThemeRef` tokens, dark / light / high-contrast, style caching, per-control overrides | Draft |
  121. | **Lists & virtualization** | Virtualized `ListView`, `GridView`, `ItemsRepeater`, `LazyStack` with recycling | Draft |
  122. | **Input & gestures** | Pan / pinch / rotate / long-press gesture recognizers, drag-and-drop with typed data transfer, pointer and focus management | Draft |
  123. | **Docking & windows** | Visual Studio-style docking — tab tear-off, cross-window dock-in, floating panes, splitters, reserved document area, layout serialization and migration | Draft |
  124. | **WinForms interop** | Simple hosting of WinUI content inside WinForms apps | Draft |
  125. | **DevTools & diagnostics** | In-process MCP server for AI agents, UIA tree inspection, layout-cost overlay, screenshot capture, structured log capture, ETW layout events | Draft |
  126. | **`mur` CLI & analyzers** | App scaffolding, `mur check` did-you-mean linter, localization tooling, `mur doctor` / `mur upgrade`, 40+ Roslyn analyzers (hooks, commanding, accessibility, theming, pooling, forms) | Draft |
  127. | **Localization** | ICU message format, source generator, CLI tooling (extract, translate, validate), RTL/BiDi | Early |
  128. | **Data system** | `DataGrid`, `PropertyGrid`, `FormField`, metadata model, async validation, inline editing | Early |
  129. | **Async resources** | `UseResource` / `UseInfiniteResource` / `UseMutation` — async value states, query caching, pagination, cancellation, optimistic updates | Early |
  130. | **Shell integration** | Taskbar progress and overlays, jump lists, tray icons, thumbnail toolbars, layered-window hosting (opacity, no-activate, click-through) | Early |
  131. | **Win2D canvas** | Optional `Reactor.Advanced` package — immediate-mode GPU drawing via `Win2DCanvas` / `Win2DAnimatedCanvas` / `Win2DVirtualCanvas` and draw-state hooks | Early |
  132. | **Control wrapper generator** | Source generator that turns WinUI controls into Reactor elements via `[GenerateReactorWrapper]` — auto factory methods, descriptors, two-way props | Early |
  133. | **Preview / hot reload** | `MetadataUpdateHandler` hot reload, CLI `--preview` flag, VS Code live preview | Early |
  134. | **Visual Studio embedded preview** | Experimental VSIX that reparents a live WinUI app into a Visual Studio tool window | Experimental / roughest |
  135. > Maturity labels reflect the breadth of testing and the likelihood of API churn, not feature completeness. *Preview* areas have the broadest unit and selftest coverage (plus end-to-end tests where applicable) and are the most stable — pure-managed subsystems (Flex, Markdown, Commanding) lean on exhaustive unit and selftest suites where end-to-end input isn't applicable. *Draft* areas work on the golden path but may have rough edges or partial AOT support. *Early* areas are usable but expect bigger shape changes as we iterate. The Visual Studio embedded preview is intentionally called out separately: in a repository of experiments, it is currently the roughest and most experimental surface.
  136. ---
  137. ## What's in it for you
  138. ### Fundamentals — for everyone
  139. The core framework has been through 13 days of continuous reconciler iteration, a competitive review against React, SwiftUI, and Compose, and a 275-finding code review. It targets the basics every WinUI developer cares about:
  140. - **Performance.** Element pooling, render coalescing, skip-unchanged optimization. Keyed lists reconcile with a longest-increasing-subsequence diff so reordering moves the fewest possible controls, virtualized lists recycle realized containers instead of rebuilding them on every scroll, and a dedicated allocation-reduction pass trimmed per-render modifier and hook churn.
  141. - **Stability.** Built as a system component: high reliability bar, structured logging, stress testing.
  142. - **Developer experience.** Full IntelliSense, refactoring, and compile-time type safety — no XAML string-typing, no binding errors at runtime.
  143. - **Localization.** ICU message format with pluralization, CLI extraction, and AI-assisted translation.
  144. - **Accessibility.** Full exposure of WinUI's built-in accessibility through a simple API, with inline dev-time linting and runtime validation.
  145. ### Frontier developers — a new programming model
  146. If you're excited about declarative UI and functional patterns:
  147. - **Functional MVU.** Describe UI as pure C# expressions. Familiar to React, SwiftUI, and Compose users, and a natural fit for AI-agent-assisted authoring.
  148. - **Hooks-based state** co-located with render logic — no ViewModel boilerplate, no binding expressions.
  149. - **Immutable element trees** with automatic reconciliation — describe what the UI *should* look like, not how to mutate it.
  150. - **Flex layout** via a faithful Yoga port — familiar to anyone who has used CSS flexbox.
  151. - **Declarative animation** driven by compositor-layer features — transitions, keyframes, and connected animations.
  152. ### Enterprise developers — data and productivity
  153. If you're building line-of-business applications:
  154. - **DataGrid** with headless state management, column DSL, sort, selection, keyboard navigation, inline editing, column resize, and async validation.
  155. - **PropertyGrid** with metadata-driven type-to-editor registry, recursive decomposition, and INPC integration.
  156. - **Forms & validation** pipeline with `FormField`, `ValidationRule`, and auto-validation.
  157. - **Charting.** Composable services for line, bar, area, pie, tree, and force-directed graphs, built on an industry-standard D3 port.
  158. - **Commanding** that bundles label, icon, keyboard shortcut, and action into a single definition surfaced across menus, toolbars, and context menus.
  159. - **WinForms migration.** Tools for incrementally adopting WinUI inside an existing WinForms app.
  160. ---
  161. ## Live preview
  162. Reactor includes a built-in preview mode — mount a single component in isolation with hot reload, from the CLI or VS Code.
  163. ### CLI preview
  164. Any Reactor app that passes `preview: true` to `ReactorApp.Run` supports the `--preview` flag:
  165. ```csharp
  166. ReactorApp.Run<App>("My App", preview: true);
  167. ```
  168. ```bash
  169. # Preview a specific component with hot reload
  170. dotnet watch run --project MyApp -p:Platform=x64 -- --preview CounterDemo
  171. # Preview the first component in the project
  172. dotnet watch run --project MyApp -p:Platform=x64 -- --preview
  173. # List available components
  174. dotnet run --project MyApp -p:Platform=x64 -- --preview-list
  175. ```
  176. ### VS Code extension
  177. The **Reactor Preview** extension adds a live preview panel to VS Code. It runs a single preview process and switches between components instantly over HTTP — no process restart when you change components.
  178. ```bash
  179. cd src/vscode-reactor
  180. npm install
  181. npm run compile
  182. code --install-extension vscode-reactor
  183. ```
  184. Open a C# file with a Reactor `Component`, run **Reactor: Preview Component** from the command palette, and a preview panel opens beside your editor. It auto-detects components in the current file, hot-reloads on save via `dotnet watch`, follows your editor between files in the same project, and only relaunches when you cross project boundaries.
  185. ### Visual Studio extension
  186. The Visual Studio embedded preview VSIX is available for hands-on experimentation, but it is the roughest surface in this experimental repo. Expect install friction, solution-load races, HWND/DPI edge cases, and breaking changes while it is hardened; use it for smoke testing and feedback, not as a reliable daily-driver workflow yet.
  187. ---
  188. ## How we're releasing it
  189. Reactor is on GitHub as an **experimental** project. The label will stay on for 3–6 months as we iterate on the design in the open.
  190. We are gathering feedback, pressure-testing the API surface, and refining the programming model before broadening adoption. We want the design shaped by real developer experience.
  191. Everything in the repository — framework code, specs, sample apps, test suites — is available for anyone to read, build, and experiment with. Contributions and feedback are welcome from day one.
  192. Expect change. Every line of code in this project is fair game. The DSL syntax may shift as we work with the C# language team, controls may be added or removed, layering may be reorganized. This is your chance to shape the design while the sausage is getting made.
  193. ---
  194. ## Prefer Rust?
  195. The idea isn't tied to C#. Over in [windows-rs](https://github.com/microsoft/windows-rs),
  196. the Rust for Windows project, the same experiment is running in Rust:
  197. [**windows-reactor**](https://github.com/microsoft/windows-rs/blob/HEAD/docs/crates/windows-reactor.md)
  198. is a declarative WinUI library where components own their state, controls send
  199. typed messages back, and only the WinUI controls that changed get updated. It's a
  200. separate library with its own model, available on
  201. [crates.io](https://crates.io/crates/windows-reactor). Different language, same
  202. native controls underneath.
  203. ---
  204. ## Project structure
  205. ```
  206. src/Reactor/ Core framework
  207. Core/ Reconciler, components, hooks, elements
  208. Elements/ DSL factory methods + fluent modifiers
  209. Flex/ FlexPanel — CSS Flexbox via Yoga
  210. Yoga/ Pure C# port of Meta's Yoga layout engine
  211. Hosting/ App bootstrap, render loop, hot reload, preview capture server
  212. src/Reactor.Cli/ CLI scaffolding tool
  213. src/vscode-reactor/ VS Code extension — live preview panel
  214. tests/
  215. Reactor.Tests/ xUnit unit tests — 2,200+ tests incl. 543 Yoga fixtures
  216. Reactor.AppTests/ MSTest runner — orchestrates selfhost + winapp ui
  217. Reactor.AppTests.Host/ Selfhost test app — 60+ in-process fixtures
  218. stress_perf/ Performance benchmarks
  219. samples/
  220. apps/ Sample apps (wordpuzzle, regedit, minesweeper, chat, netpulse, etc.)
  221. TodoApp/ Todo app sample
  222. ```
  223. ---
  224. ## Sample apps
  225. ### WordPuzzle — word search game
  226. A word search game demonstrating grid layout, timers, and interactive state.
  227. ```bash
  228. dotnet run --project samples/apps/wordpuzzle -p:Platform=x64
  229. ```
  230. ---
  231. ## Learn more
  232. | Doc | Description |
  233. |-----|-------------|
  234. | [Guide](https://microsoft.github.io/microsoft-ui-reactor/) | Documentation on how to use Reactor |
  235. | [Design Specs](docs/specs/) | Numbered specs covering theming, navigation, animation, data, accessibility |
  236. | [AOT support matrix](docs/aot-support.md) | Which subsystems work under `PublishAot=true` and which throw at runtime |
  237. | [Contributing](CONTRIBUTING.md) | Build, test, add features, code style |
  238. ---
  239. ## License
  240. [MIT](LICENSE)
samples/apps/monaco-editor/Monaco/Assets/vs/nls.messages.ru.js.js · Bundled script · 17 lines
  1. define("vs/nls.messages.ru.js",["./_commonjsHelpers-CT9FvmAN"],(function(n){"use strict";var e={};/*!-----------------------------------------------------------
  2. * Copyright (c) Microsoft Corporation. All rights reserved.
  3. * Version: 0.55.1(516f350bdaf7a82f6731bd128a9ec86a6e5fa47d)
  4. * Released under the MIT license
  5. * https://github.com/microsoft/vscode/blob/main/LICENSE.txt
  6. *-----------------------------------------------------------*/var t;function i(){return t||(t=1,globalThis._VSCODE_NLS_MESSAGES=["{0} ({1})","входные данные","С учетом регистра","Слово целиком","Использовать регулярное выражение","входные данные","Сохранить регистр","Проверьте этот аспект в доступном представлении с помощью {0}.",'Проверьте этот аспект в представлении с поддержкой специальных возможностей с помощью команды "Открыть представление с поддержкой специальных возможностей", которую в настоящее время нельзя активировать с помощью настраиваемого сочетания клавиш.',"Ошибка: {0}","Предупреждение: {0}","Информация: {0}"," или {0} для журнала"," ({0} для журнала)","Очищенные входные данные","свободный","Поле выбора","Дополнительные действия...","Ввод для поиска","Закрыть","Ввод для поиска","Результаты не найдены.","Нет результатов","Результатов: {0}","Введите текст для фильтра","Ввод для поиска","Фильтр","Нечеткое совпадение","(пусто)","{0}: {1}","Произошла системная ошибка ({0})","Произошла неизвестная ошибка. Подробные сведения см. в журнале.","Произошла неизвестная ошибка. Подробные сведения см. в журнале.","{0} (всего ошибок: {1})","Произошла неизвестная ошибка. Подробные сведения см. в журнале.","CTRL","SHIFT","ALT","Windows","CTRL","SHIFT","ALT","Super","CTRL","SHIFT","Параметр","Команда","CTRL","SHIFT","ALT","Windows","CTRL","SHIFT","ALT","Super","Расширения","Встроенный терминал","Чат","Телеметрия","Обновить","редактор","Сейчас редактор недоступен.","{0} Чтобы включить оптимизированный режим читателя, используйте {1}",'{0} Чтобы включить оптимизированный режим читателя, откройте быстрый выбор с помощью {1} и выполните команду "Активация режима специальных возможностей для читателя", который сейчас не может быть активирован с помощью клавиатуры.','{0} Назначьте сочетание клавиш для команды "Активация режима специальных возможностей для читателя", используя редактор настраиваемых сочетаний клавиш с помощью {1} и запустите его.',"редактор","Размещать на конце даже для более длинных строк","Размещать на конце даже для более длинных строк","Дополнительные курсоры удалены.","&&Отменить","Отменить","Отменить","&&Повторить","Вернуть","Вернуть","&&Выделить все","Выбрать все","Выбрать все","Использование отрисовки на основе DOM","Отложены ли в настоящее время встроенные завершения","Выберите длительность откладывания для встроенных предложений","Отложить встроенные предложения","Отменить откладывание встроенных предложений","Число курсоров ограничено {0}. Для проведения крупных изменений рекомендуется использовать [поиск и замену](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) или увеличить значение параметра ограничения нескольких курсоров в редакторе.","Увеличить значение ограничения нескольких курсоров","Переключатель свертывания неизмененных регионов","Показать или скрыть перемещенные блоки кода",'Переключатель "Использовать встроенное представление при ограниченном пространстве"',"Редактор несовпадений","Переключить сторону","Выйти из перемещения сравнения","Свернуть все неизмененные области","Показать все неизмененные области","Отменить изменения","Доступное представление различий","Перейти к следующему различию","Перейти к предыдущему различию",'Значок "Вставить" в средстве просмотра с поддержкой специальных возможностей инструмента сравнений','Значок "Удалить" в средстве просмотра с поддержкой специальных возможностей инструмента сравнений','Значок "Закрыть" в средстве просмотра с поддержкой специальных возможностей инструмента сравнений',"Закрыть","Доступное средство просмотра инструмента сравнения. Используйте клавиши СТРЕЛКА ВВЕРХ и СТРЕЛКА ВНИЗ для перемещения.","нет измененных строк","1 строка изменена","Строк изменено: {0}","Различие {0} из {1}: исходная строка {2}, {3}, измененная строка {4}, {5}","пустой","{0} неизмененная строка {1}","{0} исходная строка {1} измененная строка {2}","+ {0} измененная строка {1}","- {0} исходная строка {1}"," используйте {0}, чтобы открыть справку по специальным возможностям.","Копировать удаленные строки","Копировать удаленную строку","Копировать измененные строки","Копировать измененную строку","Копировать удаленную строку ({0})","Копировать измененную строку ({0})","Отменить это изменение","Использовать встроенное представление при ограниченном пространстве","Показать перемещенные блоки кода","Обратить блокировку","Обратить выделение","Открыть средство просмотра с поддержкой специальных возможностей инструмента сравнений","Свернуть неизмененную область","Скрытые строки ({0})","Щелкните или перетащите, чтобы показать больше выше","Показать неизмененный регион","Щелкните или перетащите, чтобы показать больше ниже","Скрытые строки ({0})","Дважды щелкните, чтобы развернуть","Код перемещен с изменениями в строку {0}-{1}","Код перемещен с изменениями из строки {0}-{1}","Код перемещен в строку {0}-{1}","Код перемещен из строки {0}-{1}","Отменить выбранные изменения","Отменить изменение","Цвет границы для текста, перемещенного в редакторе несовпадений.","Цвет активной границы для текста, перемещенного в редакторе несовпадений.","Цвет тени вокруг мини-приложений неизмененных областей.","Оформление строки для вставок в редакторе несовпадений.","Оформление строки для удалений в редакторе несовпадений.","Цвет фона заголовка редактора различий","Цвет фона редактора несовпадений нескольких файлов","Цвет границы редактора различий нескольких файлов","Загрузка...","Нет измененных файлов","Редактор","Число пробелов, соответствующее табуляции. Этот параметр переопределяется на основе содержимого файла, если включен параметр {0}.",'Число пробелов, используемых для отступа, либо `"tabSize"` для использования значения из "#editor.tabSize#". Этот параметр переопределяется на основе содержимого файла, если включен параметр "#editor.detectIndentation#".',"Вставлять пробелы при нажатии клавиши TAB. Этот параметр переопределяется на основе содержимого файла, если включен параметр {0}.","На основе содержимого файла определяет, будут ли {0} и {1} автоматически обнаружены при открытии файла.","Удалить автоматически вставляемый конечный пробел.","Специальная обработка для больших файлов с отключением некоторых функций, которые интенсивно используют память.","Отключите предложения на основе слов.","Предложение слов только из активного документа.","Предложение слов из всех открытых документов на одном языке.","Предложение слов из всех открытых документов.","Определяет, следует ли вычислять завершения на основе слов в документе и из каких документов они вычисляются.","Семантическое выделение включено для всех цветовых тем.","Семантическое выделение отключено для всех цветовых тем.",'Семантическое выделение настраивается с помощью параметра "semanticHighlighting" текущей цветовой темы.',"Определяет показ семантической подсветки для языков, поддерживающих ее.","Оставлять быстрый редактор открытым даже при двойном щелчке по его содержимому и при нажатии ESC.","Строки, длина которых превышает указанное значение, не будут размечены из соображений производительности","Определяет, должна ли разметка происходить асинхронно в рабочей роли.","Определяет, следует ли регистрировать асинхронную разметку. Только для отладки.","Определяет, должна ли асинхронная разметка проверяться по отношению к устаревшей фоновой разметке. Может замедлить разметку. Только для отладки.",'Определяет, следует ли включить синтаксический анализ tree sitter и собирать данные телеметрии. Параметр "#editor.experimental.preferTreeSitter#" для определенных языков обладает приоритетом.','Определяет, следует ли включать синтаксический анализ tree sitter для CSS. Этот параметр имеет приоритет над параметром "#editor.experimental.treeSitterTelemetry#" для CSS.','Определяет, следует ли включать синтаксический анализ tree sitter для TypeScript. Этот параметр имеет приоритет над параметром "#editor.experimental.treeSitterTelemetry#" для TypeScript.','Определяет, следует ли включать синтаксический анализ tree sitter для ini. Этот параметр имеет приоритет над параметром "#editor.experimental.treeSitterTelemetry#" для ini.','Определяет, следует ли включать синтаксический анализ tree sitter для регулярного выражения. Этот параметр имеет приоритет над параметром "#editor.experimental.treeSitterTelemetry#" для регулярного выражения.',"Определяет символы скобок, увеличивающие или уменьшающие отступ.","Открывающий символ скобки или строковая последовательность.","Закрывающий символ скобки или строковая последовательность.","Определяет пары скобок, цвет которых зависит от их уровня вложения, если включена опция выделения цветом.","Открывающий символ скобки или строковая последовательность.","Закрывающий символ скобки или строковая последовательность.","Время ожидания в миллисекундах, по истечении которого вычисление несовпадений отменяется. Укажите значение 0, чтобы не использовать время ожидания.","Максимальный размер файла в МБ для вычисления различий. Используйте 0 без ограничений.","Определяет, как редактор несовпадений отображает отличия: рядом или в тексте.","Если ширина редактора несовпадений меньше этого значения, используется встроенное представление.","Если параметр включен и ширина редактора слишком мала, используется встроенное представление.","Если этот параметр включен, в редакторе несовпадений на поле глифа отображаются стрелки для отмены изменений.","Если этот параметр включен, в редакторе несовпадений будет отображаться особая панель для действий отмены изменений и подготовки.","Когда параметр включен, редактор несовпадений игнорирует изменения начального или конечного пробела.","Определяет, должны ли в редакторе отображаться индикаторы +/- для добавленных или удаленных изменений.","Определяет, отображается ли CodeLens в редакторе.","Строки не будут переноситься никогда.","Строки будут переноситься по ширине окна просмотра.","Строки будут переноситься в соответствии с настройкой {0}.","Использует устаревший алгоритм сравнения.","Использует расширенный алгоритм сравнения.","Определяет, отображает ли редактор несовпадений неизмененные области.","Определяет, сколько строк используется для неизмененных областей.","Определяет, сколько строк используется в качестве минимального значения для неизмененных областей.","Определяет, сколько строк используется в качестве контекста при сравнении неизмененных областей.","Определяет, должен ли редактор несовпадений показывать обнаруженные перемещения кода.","Определяет, отображает ли редактор несовпадений пустые элементы оформления, чтобы увидеть, где вставлены или удалены символы.","Если этот параметр включен и редактор использует встроенное представление, изменения слов отображаются встроенно.","Использовать API-интерфейсы платформы, чтобы определять, подключено ли средство чтения с экрана.","Оптимизировать для использования со средством чтения с экрана.","Предполагать, что средство чтения с экрана не подключено.","Определяет, следует ли запустить пользовательский интерфейс в режиме оптимизации для средства чтения с экрана.","Определяет, вставляется ли пробел при комментировании.","Определяет, должны ли пустые строки игнорироваться с помощью действий переключения, добавления или удаления для комментариев к строкам.","Управляет тем, копируется ли текущая строка при копировании без выделения.","Определяет, должен ли курсор перемещаться для поиска совпадений при вводе.","Никогда не вставлять начальные значения в строку поиска из выделенного фрагмента редактора.","Всегда вставлять начальные значения в строку поиска из выделенного фрагмента редактора, включая слова в позиции курсора.","Вставлять начальные значения в строку поиска только из выделенного фрагмента редактора.","Определяет, можно ли передать строку поиска в мини-приложение поиска из текста, выделенного в редакторе.","Никогда не включать функцию «Найти в выделении» автоматически (по умолчанию).","Всегда включать функцию «Найти в выделении» автоматически.","Автоматическое включение функции «Найти в выделении» при выборе нескольких строк содержимого.","Управляет условием автоматического включения функции «Найти в выделении».","Определяет, должно ли мини-приложение поиска считывать или изменять общий буфер обмена поиска в macOS.","Определяет, должно ли мини-приложение поиска добавлять дополнительные строки в начале окна редактора. Если задано значение true, вы можете прокрутить первую строку при отображаемом мини-приложении поиска.","Определяет, будет ли поиск автоматически перезапускаться с начала (или с конца), если не найдено никаких других соответствий.","Не сохранять журнал поиска из мини-приложения поиска.","Сохранение журнала поиска в активной рабочей области.","Управляет тем, как должен храниться журнал мини-приложения поиска","Не сохраняйте журнал из мини-приложения замены.","Сохранение журнала замен во всей активной рабочей области","Управляет хранением журнала мини-приложения замен",'Определяет, должна ли функция "Найти мини-приложение" выполнять поиск при вводе текста.','Включает или отключает лигатуры шрифтов (характеристики шрифта "calt" и "liga"). Измените этот параметр на строку для детального управления свойством CSS "font-feature-settings".','Явное свойство CSS "font-feature-settings". Если необходимо только включить или отключить лигатуры, вместо него можно передать логическое значение.','Настраивает лигатуры или характеристики шрифта. Можно указать логическое значение, чтобы включить или отключить лигатуры, или строку для значения свойства CSS "font-feature-settings".',"Включает или отключает преобразование из параметра font-weight в font-variation-settings. Измените этот параметр на строку для детального управления свойством CSS font-variation-settings.","Явное свойство CSS font-variation-settings. Если необходимо лишь преобразовать параметр font-weight в параметр font-variation-settings, вместо этого свойства можно передать логическое значение.","Настраивает варианты шрифтов. Может представлять собой логическое значение для включения или отключения преобразования из параметра font-weight в параметр font-variation-settings или строку, содержащую значение свойства CSS font-variation-settings.","Определяет размер шрифта в пикселях.",'Допускаются только ключевые слова "normal" или "bold" и числа в диапазоне от 1 до 1000.','Управляет насыщенностью шрифта. Допустимые значения: ключевые слова "normal" или "bold", а также числа в диапазоне от 1 до 1000.',"Показать предварительные результаты (по умолчанию)","Перейти к основному результату и показать быстрый редактор","Перейти к основному результату и включить быструю навигацию для остальных","Этот параметр устарел. Используйте вместо него отдельные параметры, например, 'editor.editor.gotoLocation.multipleDefinitions' или 'editor.editor.gotoLocation.multipleImplementations'.",'Управляет поведением команды "Перейти к определению" при наличии нескольких целевых расположений.','Управляет поведением команды "Перейти к определению типа" при наличии нескольких целевых расположений.','Управляет поведением команды "Перейти к объявлению" при наличии нескольких целевых расположений.','Управляет поведением команды "Перейти к реализациям" при наличии нескольких целевых расположений.','Управляет поведением команды "Перейти к ссылкам" при наличии нескольких целевых расположений.','Идентификатор альтернативной команды, выполняемой в том случае, когда результатом операции "Перейти к определению" является текущее расположение.','Идентификатор альтернативной команды, которая выполняется в том случае, если результатом операции "Перейти к определению типа" является текущее расположение.','Идентификатор альтернативный команды, выполняемой в том случае, когда результатом операции "Перейти к объявлению" является текущее расположение.','Идентификатор альтернативный команды, выполняемой, когда результатом команды "Перейти к реализации" является текущее расположение.','Идентификатор альтернативной команды, выполняемой в том случае, когда результатом выполнения операции "Перейти к ссылке" является текущее расположение.',"Управляет тем, отображается ли наведение.","Определяет время задержки в миллисекундах перед отображением наведения.","Управляет тем, должно ли наведение оставаться видимым при наведении на него курсора мыши.",'Определяет время задержки в миллисекундах перед скрытием наведения. Требуется включить "#editor.linkedEditing#".',"Предпочитать отображать наведение над строкой, если есть место.","Предполагает, что все символы имеют одинаковую ширину. Это быстрый алгоритм, который работает правильно для моноширинных шрифтов и некоторых скриптов (например, латинских символов), где глифы имеют одинаковую ширину.","Делегирует вычисление точек переноса браузеру. Это медленный алгоритм, который может привести к зависаниям при обработке больших файлов, но работает правильно во всех случаях.","Управляет алгоритмом, который вычисляет точки переноса. Обратите внимание, что в режиме специальных возможностей будет использован расширенный алгоритм, чтобы обеспечить наибольшее удобство работы.","Отключить меню действий кода.","Показывать меню действий кода, если курсор находится в строках с кодом.","Показывать меню действий кода, если курсор находится на строках с кодом или на пустых строках.","Включает значок лампочки для действия кода в редакторе.","Отображает вложенные текущие области во время прокрутки в верхней части редактора.","Определяет максимальное число залипающих линий для отображения.","Определяет модель, используемую для определения строк залипания. Если модель структуры не существует, она откатится к модели поставщика свертывания, которая откатывается к модели отступов. Этот порядок соблюдается во всех трех случаях.","Включить закрепленную прокрутку с помощью горизонтальной полосы прокрутки редактора.","Включает вложенные указания в редакторе.","Вложенные указания включены.","Вложенные указания отображаются по умолчанию и скрываются удержанием клавиш {0}.","Вложенные указания по умолчанию скрыты и отображаются при удержании {0}.","Вложенные указания отключены.","Управляет размером шрифта вложенных указаний в редакторе. По умолчанию {0} используется, когда сконфигурированное значение меньше {1} или больше размера шрифта редактора.","Управляет семейством шрифтов для вложенных указаний в редакторе. Если значение не задано, используется {0}.","Включает поля вокруг вложенных указаний в редакторе.",'Максимальная общая длина вложенных указаний для одной строки, прежде чем они будут обрезаны редактором. Задайте значение "0", чтобы никогда не усекать',`Определяет высоту строки. \r
  7. – Используйте 0, чтобы автоматически вычислить высоту строки на основе размера шрифта.\r
  8. – Значения от 0 до 8 будут использоваться в качестве множителя для размера шрифта.\r
  9. – Значения больше или равные 8 будут использоваться в качестве действующих значений.`,"Определяет, отображается ли мини-карта.","Мини-карта всегда отображается.","Мини-карта скрыта, когда мышь не находится над мини-картой, и отображается, когда мышь наведена на мини-карту.","Мини-карта отображается только при прокрутке редактора","Определяет, скрыта ли мини-карта автоматически.","Мини-карта имеет такой же размер, что и содержимое редактора (возможна прокрутка).","Мини-карта будет растягиваться или сжиматься по мере необходимости, чтобы заполнить редактор по высоте (без прокрутки).","Миникарта будет уменьшаться по мере необходимости, чтобы никогда не быть больше, чем редактор (без прокрутки).","Управляет размером миникарты.","Определяет, с какой стороны будет отображаться мини-карта.","Определяет, когда отображается ползунок мини-карты.","Масштаб содержимого, нарисованного на мини-карте: 1, 2 или 3.","Отображает фактические символы в строке вместо цветных блоков.","Ограничивает ширину мини-карты, чтобы количество отображаемых столбцов не превышало определенное количество.","Определяет, отображаются ли именованные области в виде заголовков разделов на мини-карте.",'Определяет, отображаются ли комментарии "MARK:" в виде заголовков разделов на мини-карте.','Определяет регулярное выражение, используемое для поиска заголовков разделов в комментариях. Регулярное выражение должно содержать именованную группу соответствия "label" (записанную как "(?<label>.+)"), которая инкапсулирует заголовок раздела, в противном случае она не будет работать. При необходимости можно включить другую группу совпадений с именем "разделитель". Используйте \\n в шаблоне для сопоставления многострокового заголовка.',"Определяет размер шрифта заголовков разделов на мини-карте.","Управляет объемом пространства (в пикселях) между символами заголовка раздела. Это улучшает удобочитаемость заголовка при небольших размерах шрифтов.","Задает пространство между верхним краем редактора и первой строкой.","Задает пространство между нижним краем редактора и последней строкой.","Включает всплывающее окно с документацией по параметру и сведениями о типе, которое отображается во время набора.","Определяет, меню подсказок остается открытым или закроется при достижении конца списка.","Экспресс-предложения отображаются в мини-приложении рекомендаций","Экспресс-предложения отображаются как едва различимый текст","Экспресс-предложения отключены","Разрешение кратких предложений в строках.","Разрешение кратких предложений в комментариях.","Разрешение кратких предложений вне строк и комментариев.","Определяет, должны ли предложения автоматически отображаться при вводе. Этот параметр можно выбрать при вводе примечаний, строк и другого кода. Быстрые предложения можно настроить для отображения в виде фантомного текста или в мини-приложении предложений. Необходимо также помнить о параметре {0}, который управляет активированием предложений специальными символами.","Номера строк не отображаются.","Отображаются абсолютные номера строк.","Отображаемые номера строк вычисляются как расстояние в строках до положения курсора.","Номера строк отображаются каждые 10 строк.","Управляет отображением номеров строк.","Число моноширинных символов, при котором будет отрисовываться линейка этого редактора.","Цвет линейки этого редактора.","Отображать вертикальные линейки после определенного числа моноширинных символов. Для отображения нескольких линеек укажите несколько значений. Если не указано ни одного значения, вертикальные линейки отображаться не будут.","Вертикальная полоса прокрутки будет видна только при необходимости.","Вертикальная полоса прокрутки всегда будет видна.","Вертикальная полоса прокрутки всегда будет скрыта.","Управляет видимостью вертикальной полосы прокрутки.","Горизонтальная полоса прокрутки будет видна только при необходимости.","Горизонтальная полоса прокрутки всегда будет видна.","Горизонтальная полоса прокрутки всегда будет скрыта.","Управляет видимостью горизонтальной полосы прокрутки.","Ширина вертикальной полосы прокрутки.","Высота горизонтальной полосы прокрутки.","Управляет прокруткой при нажатии страницы или переходом к позиции щелчка.","При установке этого параметра горизонтальная полоса прокрутки не будет увеличивать размер содержимого редактора.","Управляет выделением всех нестандартных символов ASCII. Базовыми ASCII считаются только символы между U+0020 и U+007E, табуляция, перевод строки и возврат каретки.","Определяет, выделяются ли символы, которые просто резервируют пространство или вообще не имеют ширины.","Управляет выделением символов, которые можно спутать с основными символами ASCII, кроме тех, которые являются общими в текущем языковом стандарте пользователя.","Определяет, должны ли символы в комментариях также выделяться в Юникоде.","Определяет, должны ли символы в строках также выделяться в Юникоде.","Определяет разрешенные символы, которые не выделяются.","Символы Юникода, распространенные в разрешенных языках, не выделяются.","Определяет, следует ли автоматически показывать встроенные предложения в редакторе.","Отображать панель инструментов встроенного предложения при каждом отображении встроенного предложения.","Отображать панель инструментов предложений при наведении указателя мыши на встроенное предложение.","Не показывать встроенную панель инструментов с предложениями.","Определяет, когда отображать встроенную панель инструментов предложений.","Определяет, следует ли отображать выделения синтаксиса для встроенных предложений в редакторе.","Управляет взаимодействием встроенных предложений с мини-приложением предложений. Если этот параметр включен, мини-приложение предложений не отображается автоматически, когда доступны встроенные предложения.","Определяет, подавляются ли встроенные предложения в режиме фрагмента кода.","Управляет минимальной задержкой в миллисекундах, по истечении которой отображаются встроенные предложения после ввода.","Подавляет встроенные дополнения для указанных идентификаторов расширений — через запятую.","Определяет, следует ли отправлять сведения запроса из поставщика встроенных предложений.","Определяет, запускать ли команду при изменении поставщика встроенных предложений.","Управляет отображением встроенных предложений в случае конфликта предложений.","Управляет семейством шрифтов встроенных предложений.","Определяет, будет ли отображение предложения сдвигать код, чтобы освободить место для встраивания предложения.","Определяет, могут ли отображаться более крупные предложения рядом.","Очень крупные предложения будут отображаться рядом, если достаточно места. В противном случае они будут демонстрироваться ниже.","Очень крупные предложения никогда не отображаются рядом и всегда демонстрируются ниже.","Определяет, будет ли предложение отображаться как свернутое до прыжка к нему.","Определяет, включена ли раскраска пар скобок. Используйте {0} для переопределения цветов выделения скобок.","Определяет, имеет ли каждый тип скобок собственный независимый пул цветов.","Включение направляющих для пар скобок.","Включение направляющих для пар скобок только для активной пары скобок.","Отключение направляющих для пар скобок.","Определяет, включены ли направляющие пар скобок.","Включение горизонтальных направляющих в дополнение к вертикальным направляющим для пар скобок.","Включение горизонтальных направляющих только для активной пары скобок.","Отключение горизонтальных направляющих для пар скобок.","Определяет, включены ли горизонтальные направляющие для скобок.","Управляет тем, должна ли выделяться активная пара квадратных скобок в редакторе.","Определяет, должны ли в редакторе отображаться направляющие отступа.","Выделяет активную направляющую отступа.","Выделяет активную направляющую отступа, даже если выделены направляющие скобок.","Не выделять активную направляющую отступа.","Управляет тем, должна ли выделяться активная направляющая отступа в редакторе.","Вставить предложение без перезаписи текста справа от курсора.","Вставить предложение и перезаписать текст справа от курсора.","Определяет, будут ли перезаписываться слова при принятии вариантов завершения. Обратите внимание, что это зависит от расширений, использующих эту функцию.","Управляет тем, допускаются ли небольшие опечатки в предложениях фильтрации и сортировки.","Определяет, следует ли учитывать при сортировке слова, расположенные рядом с курсором.",'Определяет, используются ли сохраненные варианты выбора предложений совместно несколькими рабочими областями и окнами (требуется "#editor.suggestSelection#").',"Всегда выбирать предложение при автоматической активации IntelliSense.","Никогда не выбирать предложение при автоматической активации IntelliSense.","Выбирать предложение только при активации IntelliSense с помощью триггерного символа.","Выбирать предложение только при активации IntelliSense по мере ввода.","Определяет, выбирается ли предложение при отображении мини-приложения. Обратите внимание, что этот параметр применяется только к автоматически активированным предложениям ({0} и {1}) и что предложение всегда выбирается при явном вызове, например с помощью клавиш CTRL+ПРОБЕЛ.","Определяет, запрещает ли активный фрагмент кода экспресс-предложения.","Указывает, нужно ли отображать значки в предложениях.","Определяет видимость строки состояния в нижней части виджета предложений.","Определяет, следует ли просматривать результат предложения в редакторе.","Определяет, отображаются ли сведения о предложении в строке вместе с меткой или только в мини-приложении сведений.","Этот параметр является нерекомендуемым. Теперь размер мини-приложения предложений можно изменить.","Этот параметр устарел. Используйте вместо него отдельные параметры, например, 'editor.suggest.showKeywords' или 'editor.suggest.showSnippets'.",'Когда параметр включен, в IntelliSense отображаются предложения "method".','Когда параметр включен, в IntelliSense отображаются предложения "function".','Когда параметр включен, в IntelliSense отображаются предложения "constructor".','Когда параметр включен, в IntelliSense отображаются предложения "deprecated".','При включении фильтрации IntelliSense необходимо, чтобы первый символ совпадал в начале слова, например "c" в "Console" или "WebContext", но _не_ в "description". Если параметр отключен, IntelliSense отображает больше результатов, но по-прежнему сортирует их по качеству соответствия.','Когда параметр включен, в IntelliSense отображаются предложения "field".','Когда параметр включен, в IntelliSense отображаются предложения "variable".','Когда параметр включен, в IntelliSense отображаются предложения "class".','Когда параметр включен, в IntelliSense отображаются предложения "struct".','Когда параметр включен, в IntelliSense отображаются предложения "interface".','Когда параметр включен, в IntelliSense отображаются предложения "module".','Когда параметр включен, в IntelliSense отображаются предложения "property".','Когда параметр включен, в IntelliSense отображаются предложения "event".','Когда параметр включен, в IntelliSense отображаются предложения "operator".','Когда параметр включен, в IntelliSense отображаются предложения "unit".','Когда параметр включен, в IntelliSense отображаются предложения "value".','Когда параметр включен, в IntelliSense отображаются предложения "constant".','Когда параметр включен, в IntelliSense отображаются предложения "enum".','Когда параметр включен, в IntelliSense отображаются предложения "enumMember".','Когда параметр включен, в IntelliSense отображаются предложения "keyword".','Когда параметр включен, в IntelliSense отображаются предложения "text".','Когда параметр включен, в IntelliSense отображаются предложения "color".','Когда параметр включен, в IntelliSense отображаются предложения "file".','Когда параметр включен, в IntelliSense отображаются предложения "reference".','Когда параметр включен, в IntelliSense отображаются предложения "customcolor".','Когда параметр включен, в IntelliSense отображаются предложения "folder".','Когда параметр включен, в IntelliSense отображаются предложения "typeParameter".','Когда параметр включен, в IntelliSense отображаются предложения "snippet".','Во включенном состоянии IntelliSense показывает предложения типа "пользователи".','Во включенном состоянии IntelliSense отображает предложения типа "проблемы".',"Должны ли всегда быть выбраны начальный и конечный пробелы.",'Следует ли выбирать вложенные слова (например, "foo" в "fooBar" или "foo_bar").',"Языки, используемые для сегментации слов при навигации, связанной со словами, или при выполнении операций, связанных со словами. Укажите тег BCP 47 языка распознаваемого слова (пример: ja, zh-CN, zh-Hant-TW, и т. д.).","Без отступа. Перенос строк начинается со столбца 1.","Перенесенные строки получат тот же отступ, что и родительская строка.","Перенесенные строки получат отступ, увеличенный на единицу по сравнению с родительской строкой. ","Перенесенные строки получат отступ, увеличенный на два по сравнению с родительской строкой.","Управляет отступом строк с переносом по словам.",'Управляет возможностью перетаскивания файла в текстовый редактор при удерживании клавиши "Shift" (вместо открытия файла в редакторе).',"Определяет, отображается ли мини-приложение при сбросе файлов в редактор. Это мини-приложение позволяет управлять тем, как сбрасывается файл.","Отображать мини-приложение выбора сброса после сброса файла в редактор.","Никогда не показывать мини-приложение выбора сброса. Вместо этого всегда используется поставщик сброса по умолчанию.","Определяет, можно ли вставлять содержимое различными способами.","Определяет, отображается ли мини-приложение при вставке содержимого в редактор. Это мини-приложение позволяет управлять тем, как вставляется файл.","Отображать мини-приложение выбора вставки после вставки содержимого в редактор.","Никогда не показывать мини-приложение выбора вставки. Вместо этого всегда используется действие вставки по умолчанию.",'Определяет, будут ли предложения приниматься при вводе символов фиксации. Например, в JavaScript точка с запятой (";") может быть символом фиксации, при вводе которого предложение принимается.',"Принимать предложение при нажатии клавиши ВВОД только в том случае, если оно изменяет текст.","Определяет, будут ли предложения приниматься клавишей ВВОД в дополнение к клавише TAB. Это помогает избежать неоднозначности между вставкой новых строк и принятием предложений.","Управляет числом строк в редакторе, которые могут быть прочитаны средством чтения с экрана за один раз. При обнаружении средства чтения с экрана автоматически устанавливается значение по умолчанию 500. Внимание! При указании числа строк, превышающего значение по умолчанию, возможно снижение производительности.","Определяет, разрешать ли использование переменной высоты строк в редакторе.","Определяет, разрешать ли использование переменных шрифтов в редакторе.","Определяет, разрешать ли использование переменных шрифтов в редакторе в режиме специальных возможностей.","Содержимое редактора","Управляйте тем, объявляются ли встроенные предложения средством чтения экрана.","Использовать конфигурации языка для автоматического закрытия скобок.","Автоматически закрывать скобки только в том случае, если курсор находится слева от пробела.","Определяет, должен ли редактор автоматически добавлять закрывающую скобку при вводе пользователем открывающей скобки.","Использовать конфигурации языка для автоматического закрытия комментариев.","Автоматически закрывать комментарии только в том случае, если курсор находится слева от пробела.","Определяет, должен ли редактор автоматически закрывать комментарии при добавлении пользователем открывающего комментария.","Удалять соседние закрывающие кавычки и квадратные скобки только в том случае, если они были вставлены автоматически.","Определяет, должен ли редактор удалять соседние закрывающие кавычки или квадратные скобки при удалении.","Заменять закрывающие кавычки и скобки при вводе только в том случае, если кавычки или скобки были вставлены автоматически.","Определяет, должны ли в редакторе заменяться закрывающие кавычки или скобки при вводе.","Использовать конфигурации языка для автоматического закрытия кавычек.","Автоматически закрывать кавычки только в том случае, если курсор находится слева от пробела.","Определяет, должен ли редактор автоматически закрывать кавычки, если пользователь добавил открывающую кавычку.","Редактор не будет вставлять отступы автоматически.","Редактор будет сохранять отступ текущей строки.","Редактор будет сохранять отступы текущей строки и учитывать скобки в соответствии с синтаксисом языка.","Редактор будет сохранять отступ текущей строки, учитывать определенные языком скобки и вызывать специальные правила onEnterRules, определяемые языками.","Редактор будет сохранять отступ текущей строки, учитывать определенные языком скобки, вызывать специальные правила onEnterRules, определяемые языками и учитывать правила отступа indentationRules, определяемые языками.","Определяет, должен ли редактор автоматически изменять отступы, когда пользователи вводят, вставляют или перемещают текст или изменяют отступы строк.","Определяет, должен ли редактор автоматически устанавливать отступ для вставленного содержимого.","Определяет, должен ли редактор автоматически устанавливать отступ для вставленного содержимого, когда оно вставляется в строку. Это вступает в силу, если для autoIndentOnPaste присвоено значение true.","Использовать конфигурации языка для автоматического обрамления выделений.","Обрамлять с помощью кавычек, а не скобок.","Обрамлять с помощью скобок, а не кавычек.","Определяет, должен ли редактор автоматически обрамлять выделения при вводе кавычек или квадратных скобок.","Эмулировать поведение выделения для символов табуляции при использовании пробелов для отступа. Выделение будет применено к позициям табуляции.","Определяет, отображается ли CodeLens в редакторе.","Управляет семейством шрифтов для CodeLens.","Определяет размер шрифта в пикселях для CodeLens. Если задано значение 0, то используется 90% от размера #editor.fontSize#.","Определяет, должны ли в редакторе отображаться внутренние декораторы цвета и средство выбора цвета.","Показывать палитру при щелчке и при наведении указателя на декоратор цвета","Показывать палитру при наведении указателя на декоратор цвета","Показывать палитру при щелчке декоратора цвета","Управляет условием отображения палитры в декораторе цвета.","Управляет максимальным количеством цветовых декораторов, которые можно отрисовать в редакторе одновременно.","Включение того, что выбор с помощью клавиатуры и мыши приводит к выбору столбца.","Определяет, будет ли текст скопирован в буфер обмена с подсветкой синтаксиса.","Управляет стилем анимации курсора.","Плавная анимация курсора отключена.","Плавная анимация курсора включена, только если пользователь перемещает курсор явным жестом.","Плавная анимация курсора всегда включена.","Управляет тем, следует ли включить плавную анимацию курсора.","Управляет стилем курсора в режиме ввода со вставкой.","Управляет стилем курсора в режиме ввода с заменой.",'Определяет минимальное число видимых начальных линий (минимум 0) и конечных линий (минимум 1), окружающих курсор. Этот параметр имеет название "scrollOff" или "scrollOffset" в некоторых других редакторах.','"cursorSurroundingLines" применяется только при запуске с помощью клавиатуры или API.','"cursorSurroundingLines" принудительно применяется во всех случаях.','Определяет, когда следует принудительно применять "#editor.cursorSurroundingLines#".',`Управляет шириной курсора, когда для параметра "#editor.cursorStyle#" установлено значение 'line'`,'Управляет высотой курсора, когда для параметра "#editor.cursorStyle#" установлено значение "line". Максимальная высота курсора зависит от высоты строки.',"Определяет, следует ли редактору разрешить перемещение выделенных элементов с помощью перетаскивания.","Указывает, следует ли использовать API EditContext вместо текстового поля для управления вводом данных в редактор.",'Следует ли отображать форматированное содержимое средства чтения с экрана, когда включен параметр "#editor.editContext#".',"Использовать обычную отрисовку на основе МОДЕЛИ DOM.","Использовать ускорение GPU.","Определяет, следует ли использовать экспериментальное ускорение графического процессора для отображения редактора.","Использовать новый метод отрисовки с SVG.","Использовать новый метод отрисовки с символами шрифта.","Использовать стабильный метод отрисовки.","Определяет, отрисовывается ли пробел с использованием нового экспериментального метода.","Коэффициент увеличения скорости прокрутки при нажатии клавиши ALT.","Определяет, включено ли свертывание кода в редакторе.","Используйте стратегию свертывания для конкретного языка, если она доступна, в противном случае используйте стратегию на основе отступов.","Используйте стратегию свертывания на основе отступов.","Управляет стратегией для вычисления свертываемых диапазонов.","Определяет, должен ли редактор выделять сложенные диапазоны.","Определяет, будет ли редактор автоматически сворачивать диапазоны импорта.","Максимальное количество свертываемых регионов. Увеличение этого значения может привести к снижению скорости отклика редактора, если текущий источник содержит большое количество свертываемых регионов.","Определяет, будет ли щелчок пустого содержимого после свернутой строки развертывать ее.","Определяет семейство шрифтов.","Определяет, будет ли редактор автоматически форматировать вставленное содержимое. Модуль форматирования должен быть доступен и иметь возможность форматировать диапазон в документе.","Управляет параметром, определяющим, должен ли редактор автоматически форматировать строку после ввода.","Управляет отображением вертикальных полей глифа в редакторе. Поля глифа в основном используются для отладки.","Управляет скрытием курсора в обзорной линейке.","Сделать прокрутку инерционной — это особенно полезно при использовании сенсорной панели в Linux.","Управляет интервалом между буквами в пикселях.","Определяет, включена ли поддержка связанного редактирования в редакторе. В зависимости от языка, связанные символы, например теги HTML, обновляются при редактировании.","Определяет, должен ли редактор определять ссылки и делать их доступными для щелчка.","Выделять соответствующие скобки.","Множитель, используемый для параметров deltaX и deltaY событий прокрутки колесика мыши.",'Увеличьте шрифт редактора, используя колесо мыши и удерживая "Cmd".',"Изменение размера шрифта в редакторе при нажатой клавише CTRL и движении колесика мыши.","Объединить несколько курсоров, когда они перекрываются.","Соответствует клавише CTRL в Windows и Linux и клавише COMMAND в macOS.","Соответствует клавише ALT в Windows и Linux и клавише OPTION в macOS.",'Модификатор, который будет использоваться для добавления нескольких курсоров с помощью мыши. Жесты мыши "Перейти к определению" и "Открыть ссылку" будут изменены так, чтобы они не конфликтовали c [multicursor modifier](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).',"Управляет действиями при нажатии средней кнопки мыши в редакторе.","Каждый курсор вставляет одну строку текста.","Каждый курсор вставляет полный текст.","Управляет вставкой, когда число вставляемых строк соответствует числу курсоров.","Управляет максимальным числом курсоров, которые могут одновременно отображаться в активном редакторе.","Не выделяет вхождения.","Выделяет вхождения только в текущем файле.","Экспериментальная функция: выделяет вхождения во всех допустимых открытых файлах.","Определяет, следует ли выделять вхождения в открытых файлах.","Управляет задержкой в миллисекундах, после которой выделяются вхождения.","Управляет заменой при вставке.","Определяет, должна ли отображаться граница на обзорной линейке.","Фокусировка на дереве при открытии обзора","Фокусировка на редакторе при открытии обзора","Определяет, следует ли переключить фокус на встроенный редактор или дерево в виджете обзора.","Определяет, всегда ли жест мышью для перехода к определению открывает мини-приложение быстрого редактирования.","Управляет длительностью задержки (в мс) перед отображением кратких предложений.","Определяет, выполняет ли редактор автоматическое переименование по типу.",'Не рекомендуется; используйте вместо этого параметр "#editor.linkedEditing#".',"Определяет, должны ли в редакторе отображаться управляющие символы.","Отображение номера последней строки, когда файл заканчивается новой строкой.","Выделяет поле и текущую строку.","Определяет, должен ли редактор выделять текущую строку.","Определяет, должен ли редактор отрисовывать выделение текущей строки, только когда он находится в фокусе.","Отрисовка пробелов, кроме одиночных пробелов между словами.","Отображать пробелы только в выделенном тексте.","Отображать только конечные пробелы.","Определяет, должны ли в редакторе отображаться пробелы.","Управляет тем, необходимо ли отображать скругленные углы для выделения.","Управляет количеством дополнительных символов, на которое содержимое редактора будет прокручиваться по горизонтали.","Определяет, будет ли содержимое редактора прокручиваться за последнюю строку.","Определяет, будет ли редактор прокручиваться при нажатии средней кнопки.","Прокрутка только вдоль основной оси при прокрутке по вертикали и горизонтали одновременно. Предотвращает смещение по горизонтали при прокрутке по вертикали на трекпаде.","Контролирует, следует ли поддерживать первичный буфер обмена Linux.","Определяет, должен ли редактор выделять совпадения, аналогичные выбранному фрагменту.",'Управляет тем, сколько символов может быть в выделении, прежде чем похожие совпадения не будут выделены. Установите значение "ноль" для неограниченного количества.',"Определяет, должен ли редактор выделять в выбранном фрагменте совпадения, охватывающие несколько строк.","Всегда показывать свертываемые элементы управления.","Никогда не показывать элементы управления свертыванием и уменьшать размер переплета.","Показывать только элементы управления свертывания, когда указатель мыши находится над переплетом.","Определяет, когда элементы управления свертывания отображаются на переплете.","Управляет скрытием неиспользуемого кода.","Управляет перечеркиванием устаревших переменных.","Отображать предложения фрагментов поверх других предложений.","Отображать предложения фрагментов под другими предложениями.","Отображать предложения фрагментов рядом с другими предложениями.","Не отображать предложения фрагментов.","Управляет отображением фрагментов вместе с другими предложениями и их сортировкой.","Определяет, будет ли использоваться анимация при прокрутке содержимого редактора","Определяет, следует ли предоставлять указание о специальных возможностях пользователям средства чтения с экрана при отображении встроенного завершения.","Размер шрифта для мини-приложения предложений. Если установлено {0}, используется значение {1}.","Высота строки для мини-приложения предложений. Если установлено {0}, используется значение {1}. Минимальное значение — 8.","Определяет, должны ли при вводе триггерных символов автоматически отображаться предложения.","Всегда выбирать первое предложение.",'Выбор недавних предложений, если только дальнейший ввод не приводит к использованию одного из них, например "console.| -> console.log", так как "log" недавно использовался для завершения.','Выбор предложений с учетом предыдущих префиксов, использованных для завершения этих предложений, например "co -> console" и "con -> const".',"Управляет предварительным выбором предложений при отображении списка предложений.","При использовании дополнения по TAB будет добавляться наилучшее предложение при нажатии клавиши TAB.","Отключить дополнение по TAB.",'Вставка дополнений по TAB при совпадении их префиксов. Функция работает оптимально, если параметр "quickSuggestions" отключен.',"Включает дополнения по TAB.","Управляет тем, будет ли редактор также удалять пробелы отступа следующей строки при удалении новой строки.","Необычные символы завершения строки автоматически удаляются.","Необычные символы завершения строки игнорируются.","Для необычных символов завершения строки запрашивается удаление.","Удалите необычные символы завершения строки, которые могут вызвать проблемы.","Пробелы и табуляции вставляются и удаляются в соответствии с позициями табуляции.","Использовать правило разрыва строк по умолчанию.","Не следует использовать разрывы слов для текста на китайском, японском или корейском языке (CJK). Для других текстов используется обычное поведение.","Управляет правилами разбиения по словам, используемыми для текста на китайском,японском и корейском языке (CJK).","Символы, которые будут использоваться как разделители слов при выполнении навигации или других операций, связанных со словами.","Строки не будут переноситься никогда.","Строки будут переноситься по ширине окна просмотра.",'Строки будут переноситься по "#editor.wordWrapColumn#".','Строки будут перенесены по минимальному значению из двух: ширина окна просмотра и "#editor.wordWrapColumn#".',"Управляет тем, как следует переносить строки.",'Определяет столбец переноса редактора, если значение "#editor.wordWrap#" — "wordWrapColumn" или "bounded".','Управляет тем, должен литерал "\\n" запускать перенос по словам, когда включен параметр "#editor.wordWrap#".\r\n\r\nНапример:\r\n```c\r\nchar* str="hello\\nworld"\r\n```\r\nбудет отображаться как\r\n```c\r\nchar* str="hello\\n\r\n world"\r\n```',"Показывать декораторы цвета по умолчанию, только если ни один из расширений не предоставляет декораторы цветов.","Всегда отображать декораторы цвета по умолчанию.","Никогда не показывать декораторы цвета по умолчанию.","Определяет, должны ли отображаться встроенные цветовые оформления с использованием поставщика цвета документа по умолчанию.","Определяет, получает ли редактор вкладки или откладывает ли их в рабочую среду для навигации.","Цвет фона для выделения строки в позиции курсора.","Цвет фона границ вокруг строки в позиции курсора.","Цвет фона для выделенных диапазонов, например при использовании функций Quick Open или поиска. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона обводки выделения.",'Цвет фона выделенного символа, например, в функциях "Перейти к определению" или "Перейти к следующему/предыдущему символу". Цвет должен быть прозрачным, чтобы не скрывать оформление текста под ним.',"Цвет фона для границы вокруг выделенных символов.","Цвет курсора редактора.","Цвет фона курсора редактора. Позволяет настраивать цвет символа, перекрываемого прямоугольным курсором.","Цвет основного курсора редактора при наличии нескольких курсоров.","Цвет фона основного курсора редактора при наличии нескольких курсоров. Дает возможность настраивать цвет символа, перекрываемого блочным курсором.","Цвет дополнительных курсоров редактора при наличии нескольких курсоров.","Цвет фона дополнительных курсоров редактора при наличии нескольких курсоров. Дает возможность настраивать цвет символа, перекрываемого блочным курсором.","Цвет пробелов в редакторе.","Цвет номеров строк редактора.","Цвет направляющих для отступов редактора.",'Свойство "editorIndentGuide.background" является нерекомендуемым. Вместо этого используйте "editorIndentGuide.background1".',"Цвет активных направляющих для отступов редактора.",'Свойство "editorIndentGuide.activeBackground" является нерекомендуемым. Вместо этого используйте "editorIndentGuide.activeBackground1".',"Цвет направляющих для отступов редактора (1).","Цвет направляющих для отступов редактора (2).","Цвет направляющих для отступов редактора (3).","Цвет направляющих для отступов редактора (4).","Цвет направляющих для отступов редактора (5).","Цвет направляющих для отступов редактора (6).","Цвет активных направляющих для отступов редактора (1).","Цвет активных направляющих для отступов редактора (2).","Цвет активных направляющих для отступов редактора (3).","Цвет активных направляющих для отступов редактора (4).","Цвет активных направляющих для отступов редактора (5).","Цвет активных направляющих для отступов редактора (6).","Цвет номера активной строки редактора","Параметр 'Id' является устаревшим. Используйте вместо него параметр 'editorLineNumber.activeForeground'.","Цвет номера активной строки редактора","Цвет последней строки редактора, когда editor.renderFinalNewline имеет значение dimmed.","Цвет линейки редактора.","Цвет переднего плана элемента CodeLens в редакторе","Цвет фона парных скобок","Цвет прямоугольников парных скобок","Цвет границы для линейки в окне просмотра.","Цвет фона обзорной линейки редактора.","Цвет фона поля в редакторе. В поле размещаются отступы глифов и номера строк.","Цвет границы для ненужного (неиспользуемого) исходного кода в редакторе.",'Непрозрачность ненужного (неиспользуемого) исходного кода в редакторе. Например, "#000000c0" отображает код с непрозрачностью 75 %. В высококонтрастных темах для выделения ненужного кода вместо затенения используйте цвет темы "editorUnnecessaryCode.border".',"Цвет границы для едва различимого текста в редакторе.","Цвет переднего плана для едва различимого текста в редакторе.","Цвет фона для едва различимого текста в редакторе.","Цвет маркера обзорной линейки для выделения диапазонов. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет метки линейки в окне просмотра для ошибок.","Цвет метки линейки в окне просмотра для предупреждений.","Цвет метки линейки в окне просмотра для информационных сообщений.","Цвет переднего плана для скобок (1). Требуется включить раскраску парных скобок.","Цвет переднего плана для скобок (2). Требуется включить раскраску парных скобок.","Цвет переднего плана для скобок (3). Требуется включить раскраску парных скобок.","Цвет переднего плана для скобок (4). Требуется включить раскраску парных скобок.","Цвет переднего плана для скобок (5). Требуется включить раскраску парных скобок.","Цвет переднего плана для скобок (6). Требуется включить раскраску парных скобок.","Цвет переднего плана непредвиденных скобок.","Цвет фона неактивных направляющих пар скобок (1). Требуется включить направляющие пар скобок.","Цвет фона неактивных направляющих пар скобок (2). Требуется включить направляющие пар скобок.","Цвет фона неактивных направляющих пар скобок (3). Требуется включить направляющие пар скобок.","Цвет фона неактивных направляющих пар скобок (4). Требуется включить направляющие пар скобок.","Цвет фона неактивных направляющих пар скобок (5). Требуется включить направляющие пар скобок.","Цвет фона неактивных направляющих пар скобок (6). Требуется включить направляющие пар скобок.","Цвет фона активных направляющих пар скобок (1). Требуется включить направляющие пар скобок.","Цвет фона активных направляющих пар скобок (2). Требуется включить направляющие пар скобок.","Цвет фона активных направляющих пар скобок (3). Требуется включить направляющие пар скобок.","Цвет фона активных направляющих пар скобок (4). Требуется включить направляющие пар скобок.","Цвет фона активных направляющих пар скобок (5). Требуется включить направляющие пар скобок.","Цвет фона активных направляющих пар скобок (6). Требуется включить направляющие пар скобок.","Цвет границы, используемый для выделения символов Юникода.","Цвет фона, используемый для выделения символов Юникода.","Находится ли фокус на тексте в редакторе (курсор мигает)","Находится ли фокус на редакторе или на мини-приложении редактора (например, фокус находится на мини-приложении поиска)","Находится ли фокус на редакторе или на поле ввода форматированного текста (курсор мигает)","Является ли редактор доступным только для чтения","Является ли контекст редактором несовпадений","Является ли контекст внедренным редактором несовпадений","Является ли контекст несколькими редакторами несовпадений","Свернуты ли все файлы в редакторе множественных несовпадений","Содержит ли редактор несовпадений изменения","Выбран ли перемещенный блок кода для сравнения","Отображается ли средство просмотра с поддержкой специальных возможностей инструмента сравнений","Достигнута ли встроенная точка останова параллельной отрисовки редактора несовпадений","Активен ли встроенный режим","Доступен ли измененный файл для записи в редакторе несовпадений","Доступен ли измененный файл для записи в редакторе несовпадений","URI исходного документа","URI измененного документа",'Включен ли параметр "editor.columnSelection"',"Есть ли в редакторе выбранный текст","Есть ли в редакторе множественный выбор","Перемещается ли фокус с редактора при нажатии клавиши TAB","Является ли наведение в редакторе видимым","Находится ли в фокусе наведение в редакторе","Находится ли закрепленная прокрутка в фокусе","Отображается ли закрепленная прокрутка","Видна ли автономная палитра цветов","Сфокусирована ли автономная палитра цветов","Является ли редактор частью большего редактора (например, записных книжек)","Идентификатор языка редактора","Есть ли в редакторе поставщик элементов завершения","Есть ли в редакторе поставщик действий с кодом","Есть ли в редакторе поставщик CodeLens","Есть ли в редакторе поставщик определений","Есть ли в редакторе поставщик объявлений","Есть ли в редакторе поставщик реализации","Есть ли в редакторе поставщик определений типов","Есть ли в редакторе поставщик наведения","Есть ли в редакторе поставщик выделения документов","Есть ли в редакторе поставщик символов документа","Есть ли в редакторе поставщик ссылок","Есть ли в редакторе поставщик переименования","Есть ли в редакторе поставщик справки по сигнатурам","Есть ли в редакторе поставщик встроенных подсказок","Есть ли в редакторе поставщик форматирования документов","Есть ли в редакторе поставщик форматирования для выделения документов","Есть ли в редакторе несколько поставщиков форматирования документов","Есть ли в редакторе несколько поставщиков форматирования для выделения документов","Метод","Функция","Конструктор","Поле","Переменная","Класс","Структура","Интерфейс","Модуль","Свойство","Событие","Оператор","Единица","Значение","Константа","Перечисление","Элемент перечисления","Ключевое слово","Текст","Цвет","Файл","Ссылка","Дополнительный цвет","Папка","Параметр типа","Пользователь","Проблема","Инструмент","Фрагмент","массив","логическое значение","класс","константа","конструктор","перечисление","элемент перечисления","событие","поле","файл","функция","интерфейс","ключ","метод","модуль","пространство имен","NULL","число","объект","оператор","пакет","свойство","строка","структура","параметр типа","Переменная","{0} ({1})","Простой текст","Ввод","Разработчик: проверить токены","Перейти к строке/столбцу...","Показать всех поставщиков быстрого доступа","Палитра команд","Показать и выполнить команды","Перейти к символу...","Перейти к символу по категориям...","Содержимое редактора","Переключить высококонтрастную тему","Внесено изменений в файлах ({1}): {0}.","Показать больше ({0})","Символы: {0}","Начальная точка выделения","Начальная точка установлена в {0}:{1}","Установить начальную точку выделения","Перейти к начальной точке выделения","Выделить текст от начальной точки выделения до курсора","Отменить начальную точку выделения","Цвет метки линейки в окне просмотра для пар скобок.","Перейти к &&скобке","Перейти к скобке","Выбрать скобку","Выберите текст внутри, включая скобки или фигурные скобки.","Удалить скобки","Переместить выделенный текст влево","Переместить выделенный текст вправо","Транспортировать буквы","&&Вырезать","Вырезать","Вырезать","Вырезать","&&Копировать","Копирование","Копирование","Копирование","&&Вставить","Вставить","Вставить","Вставить","Копировать как","Копировать как","Поделиться","Поделиться","Копировать с выделением синтаксиса","При применении действия кода произошла неизвестная ошибка","Тип запускаемого действия кода.","Определяет, когда применяются возвращенные действия.","Всегда применять первое возвращенное действие кода.","Применить первое действие возвращенного кода, если оно является единственным.","Не применять действия возвращенного кода.","Определяет, следует ли возвращать только предпочтительные действия кода.","Доступные действия кода отсутствуют",'Нет доступных предпочтительных действий кода для "{0}".','Действия кода для "{0}" недоступны',"Нет доступных предпочтительных действий кода","Доступные действия кода отсутствуют",'Нет доступных предпочтительных рефакторингов для "{0}"','Нет доступного рефакторинга для "{0}"',"Нет доступных предпочтительных рефакторингов","Доступные операции рефакторинга отсутствуют","Нет доступных предпочтительных действий источника для '{0}'",'Нет доступных исходных действий для "{0}"',"Предпочтительные действия источника недоступны","Доступные исходные действия отсутствуют","Действие для упорядочения импортов отсутствует","Нет доступного действия по общему исправлению","Нет доступных автоисправлений","Быстрое исправление...","Рефакторинг...","Действие с исходным кодом...","Организация импортов",'Упорядочение импорта в текущем файле. Также называется "Оптимизация импорта" в некоторых средствах',"Исправить все","Автоисправление...","Включить или отключить отображение заголовков групп в меню действий кода.","Включить или отключить отображение ближайшего быстрого исправления в строке, если в этот момент не выполняется диагностика.","Включить активацию {0}, если для {1} установлено значение {2}. Для действий кода должно быть установлено значение {3}, чтобы они срабатывали при изменении окна и фокуса.","Контекст: {0} в строке {1} и столбце {2}.","Скрыть отключенные","Показать отключенные","Дополнительные действия...","Быстрое исправление","Извлечь","Встроенный","Переписать","Переместить","Разместить во фрагменте","Действие с исходным кодом","Значок, который вызывает меню действий кода из переплета, если в редакторе нет места.","Значок, который вызывает меню действий кода из переплета, если в редакторе нет места и доступно быстрое исправление.","Значок, который вызывает меню действий кода из переплета, если в редакторе нет места и доступно ИИ-исправление.","Значок, который вызывает меню действий кода из переплета, если в редакторе нет места и доступно ИИ-исправление и быстрое исправление.","Значок, который вызывает меню действий кода из переплета, если в редакторе нет места и доступно ИИ-исправление и быстрое исправление.","Запустить: {0}","Показать действия кода. Доступно предпочтительное быстрое исправление ({0})","Показать действия кода ({0})","Показать действия кода","Выберите команду","Показать команды CodeLens для текущей строки","Значок для закрытия палитры","Щелкните, чтобы переключить параметры цвета (RGB/HSL/HEX)","Здесь есть палитра.","&&Показать или выделить автономный выбор цвета","Показать или выделить автономный выбор цвета","Отображение отдельной палитры с поставщиком цвета по умолчанию или наведение фокуса на эту палитру. Отображение цветов в шестнадцатеричном формате, RGB или HSL.","Скрыть палитру цветов","Скрыть отдельную палитру.","Вставка цвета с помощью автономной палитры цветов","Вставка цветов (в шестнадцатеричном формате, RGB или HSL) с помощью отдельной палитре, на которую наведен фокус.","Переключить комментарий &&строки","Переключить комментарий &&блока","Закомментировать или раскомментировать строку","Закомментировать строку","Раскомментировать строку","Закомментировать или раскомментировать блок","Мини-карта","Отрисовка символов","Размер по вертикали","Пропорционально","Заполнить","Подогнать","Ползунок","Наведение указателя мыши","Всегда","Показать контекстное меню редактора","Отмена действия курсора","Повтор действия курсора",`Тип применяемой правки вставки.\r
  10. Если существует несколько правок для этого типа, в редакторе будет отображаться средство выбора. Если правки такого типа отсутствуют, в редакторе будет отображаться сообщение об ошибке.`,`Список предпочитаемых вариантов правок вставки для применения.\r
  11. Будет применена первая правка соответствующая настройкам.`,"Вставить как...","Вставить как текст","Отображается ли мини-приложение вставки","Показать параметры вставки...","пусто",'Изменения вставки для "{0}" не найдены',"Разрешение правки вставки для '{0}'. Щелкните, чтобы отменить","Запуск обработчиков вставки. Щелкните, чтобы отменить и выполнить обычную вставку","Настроить действие вставки по умолчанию","Выберите действие вставки","Запуск обработчиков вставки","Вставить обычный текст","Вставить URI","Вставить URI","Вставить пути","Вставить путь","Вставить относительные пути","Вставить относительный путь","Вставить HTML","Отображается ли мини-приложение сброса","Показать параметры сброса...","Запускаются обработчики сброса. Щелкните для отмены",`Ошибка при разрешении правки "{0}":\r
  12. {1}`,`Ошибка при применении изменения "{0}":\r
  13. {1}`,'Выполняются ли в редакторе операции, допускающие отмену, например, "Показать ссылки"',"Файл слишком велик для выполнения операции замены всех файлов.","&&Найти","Нет совпадений. Попробуйте найти что-нибудь другое.","Введите число, чтобы перейти к определенному совпадению (от 1 до {0})","Введите число от 1 до {0}","Введите число от 1 до {0}","&&Заменить","Найти","Найти с аргументами","Найти в выделенном фрагменте","Найти далее","Найти ранее","Перейти к совпадению...","Найти следующее выделение","Найти предыдущее выделение","Заменить","Значок, указывающий, что мини-приложение поиска в редакторе свернуто.","Значок, указывающий, что мини-приложение поиска в редакторе развернуто.",'Значок для кнопки "Найти в выбранном" в мини-приложении поиска в редакторе.','Значок для кнопки "Заменить" в мини-приложении поиска в редакторе.','Значок для кнопки "Заменить все" в мини-приложении поиска в редакторе.','Значок для кнопки "Найти ранее" в мини-приложении поиска в редакторе.','Значок для кнопки "Найти далее" в мини-приложении поиска в редакторе.',"Поиск и замена","Найти","Найти","Предыдущее совпадение","Следующее совпадение","Найти в выделении","Закрыть","Заменить","Заменить","Заменить","Заменить все","Переключение замены","Отображаются только первые {0} результатов, но все операции поиска выполняются со всем текстом.","{0} из {1}","Результаты отсутствуют","{0} обнаружено",'{0} найден для "{1}"','{0} найден для "{1}", в {2}','{0} найден для "{1}"',"Развернуть","Развернуть рекурсивно","Свернуть","Переключить свертывание","Свернуть рекурсивно","Переключить рекурсивное свертывание","Свернуть все блоки комментариев","Свернуть все регионы","Развернуть все регионы","Свернуть все кроме выбранных","Развернуть все кроме выбранных","Свернуть все","Развернуть все","Перейти к родительскому свертыванию","Перейти к предыдущему диапазону сложенных данных","Перейти к следующему диапазону сложенных данных","Создать диапазон свертывания из выделенного фрагмента","Удалить диапазоны свертывания вручную","Переключить свернутый импорт","Уровень папки {0}","Цвет фона за свернутыми диапазонами. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже декоративные элементы.","Цвет свернутого текста после первой строки сложенного диапазона.","Цвет элемента управления свертыванием во внутреннем поле редактора.","Значок для развернутых диапазонов на поле глифов редактора.","Значок для свернутых диапазонов на поле глифов редактора.","Значок для свернутых вручную диапазонов на полях глифа редактора.","Значок для развернутых вручную диапазонов на полях глифа редактора.","Щелкните, чтобы расширить диапазон.","Щелкните, чтобы свернуть диапазон.","Увеличить размер шрифта редактора","Уменьшить размер шрифта редактора","Сбросить размер шрифта редактора","Форматировать документ","Форматировать выделенный фрагмент","Значок для перехода к следующему маркеру.","Значок для перехода к предыдущему маркеру.","Следующая &&проблема","Предыдущая &&проблема","Перейти к Следующей Проблеме (Ошибке, Предупреждению, Информации)","Перейти к Предыдущей Проблеме (Ошибке, Предупреждению, Информации)","Перейти к следующей проблеме в файлах (ошибки, предупреждения, информационные сообщения)","Перейти к предыдущей проблеме в файлах (ошибки, предупреждения, информационные сообщения)","Ошибка","Предупреждение","Информация","Указание","{0} в {1}. ","Проблемы: {0} из {1}","Проблемы: {0} из {1}","Цвет ошибки в мини-приложении навигации по меткам редактора.","Фон заголовка ошибки в мини-приложении навигации по меткам редактора.","Цвет предупреждения в мини-приложении навигации по меткам редактора.","Фон заголовка предупреждения в мини-приложении навигации по меткам редактора.","Цвет информационного сообщения в мини-приложении навигации по меткам редактора.","Фон заголовка информационного сообщения в мини-приложении навигации по меткам редактора.","Фон мини-приложения навигации по меткам редактора.","Обзор","Определения",'Определение для "{0}" не найдено.',"Определения не найдены.","Перейти к &&определению","Объявления",'Объявление для "{0}" не найдено.',"Объявление не найдено","Перейти к &&объявлению",'Объявление для "{0}" не найдено.',"Объявление не найдено","Определения типов",'Не найдено определение типа для "{0}".',"Не найдено определение типа.","Перейти к &&определению типа","Реализации",'Не найдена реализация для "{0}".',"Не найдена реализация.","Перейти к &&реализациям",'Ссылки для "{0}" не найдены',"Ссылки не найдены","Перейти к &&ссылкам","Ссылки","Ссылки","Расположения",'Нет результатов для "{0}"',"Ссылки","Перейти к определению","Открыть определение сбоку","Показать определение","Перейти к объявлению","Просмотреть объявление","Перейти к определению типа","Показать определение типа","Перейти к реализациям","Просмотреть реализации","Перейти к ссылкам","Показать ссылки","Перейти к любому символу","Щелкните, чтобы отобразить определения ({0}).",'Открыто ли окно просмотра ссылок, например, "Ссылки для просмотра" или "Определение просмотра"',"Загрузка...","{0} ({1})","Ссылок: {0}","{0} ссылка","Ссылки","предварительный просмотр недоступен","Результаты отсутствуют","Ссылки","в {0} в строке {1} в столбце {2}","{0} в {1} в строке {2} в столбце {3}","1 символ в {0}, полный путь: {1}","{0} символов в {1}, полный путь: {2} ","Результаты не найдены","Обнаружен 1 символ в {0}","Обнаружено {0} символов в {1}","Обнаружено {0} символов в {1} файлах","Существуют ли расположения символов, к которым можно перейти только с помощью клавиатуры","Символ {0} из {1}, {2} для следующего","Символ {0} из {1}","Статистика текстурного атласа журнала","Сохранение текстурного атласа","Нарисовать глиф","Разработчик: редактор отладки GPU-отрисовщика","Увеличить уровень детализации в мини-приложении наведения","Уменьшить уровень детализации в мини-приложении наведения","При наведении указатель мыши не будет автоматически фокусироваться.","При наведении указателя мыши будет фокусировка произойдет только в том случае, если он уже виден.","Когда он появится, при наведении указателя мыши произойдет автоматическая фокусировка.","Показать наведение или перевести на него фокус","Показать мини-приложение наведения в редакторе или перенести на него фокус. В этом мини-приложении отображается документация, ссылки и другое содержимое для символа в текущей позиции курсора.","Отображать предварительный просмотр определения при наведении курсора мыши","Показывать предварительный просмотр определения в мини-приложении наведения в редакторе.","Скрыть наведение","Прокрутить наведение вверх","Прокрутить вверх в редакторе в мини-приложении наведения.","Прокрутить наведение вниз","Прокрутить вниз в редакторе в мини-приложении наведения.","Прокрутить наведение влево","Прокрутить влево в редакторе в мини-приложении наведения.","Прокрутить наведение вправо","Прокрутить вправо в редакторе в мини-приложении наведения.","Перейти на страницу вверх в наведении","Предыдущая страница в редакторе при наведении.","Перейти на страницу вниз в наведении","Следующая страница в редакторе при наведении.","Перейти к верхнему наведению","Перейти к верхней части редактора в мини-приложении наведения.","Перейти к нижнему наведению","Перейти к нижней части редактора в мини-приложении наведения.","Копировать","Скопировано в буфер обмена","Значок для увеличения уровня детализации.","Значок для снижения уровня детализации в мини-приложении наведения.","Загрузка...","Отрисовка приостановлена для длинной строки из соображений производительности. Это можно настроить с помощью параметра editor.stopRenderingLineAfter.",'Разметка пропускается для длинных строк из соображений производительности. Это можно настроить с помощью "editor.maxTokenizationLineLength".',"Увеличить уровень детализации при наведении ({0})","Увеличить уровень детализации при наведении","Уменьшить уровень детализации при наведении ({0})","Уменьшить уровень детализации при наведении","Просмотреть проблему","Исправления недоступны","Проверка наличия исправлений...","Исправления недоступны","Быстрое исправление...","Настроенный размер шага табуляции","Размер табуляции по умолчанию","Текущий размер табуляции","Выбрать размер шага табуляции для текущего файла","Преобразовать отступ в пробелы","Преобразовать отступы табуляцией в пробелы.","Преобразовать отступ в шаги табуляции","Преобразовать отступы пробелами в табуляцию.","Отступ с использованием табуляции","Использовать табуляцию для отступов.","Отступ с использованием пробелов","Использовать пробелы для отступов.","Изменить отображаемый размер табуляции","Изменение эквивалента размера пространства для вкладки.","Определение отступа от содержимого","Определение отступа от содержимого.","Повторно расставить отступы строк","Повторно применить отступы к строкам редактора.","Повторно расставить отступы для выбранных строк","Повторно применить отступы к выделенным строкам редактора.","Дважды щелкните, чтобы вставить","CMD + щелчок","CTRL + щелчок","OPTION + щелчок","ALT + щелчок","Перейти к определению ({0}), щелкните правой кнопкой мыши для просмотра дополнительных сведений","Перейти к определению ({0})","Выполнить команду","Переключение встроенных предложений в редакторе.","Параметры переключения встроенных предложений.","Нет доступных встроенных предложений.","Принять слово","Принять строку","Принять","Принять","Перейти","Reject","Всегда отображать панель инструментов","Разработчик: извлечение состояния встроенного предложения","Показывать следующее встроенное предложение","Показать предыдущее встроенное предложение","Активировать встроенное предложение","Принять следующее слово встроенного предложения","Принять следующую строку встроенного предложения","Принять встроенное предложение","Перейти к следующей встроенной правке","Скрыть встроенное предложение","Переключить отображение свернутых встроенных предложений","Отображается ли встроенное предложение","Начинается ли встроенное предложение с пробела","Проверяет, не является ли пробел перед встроенной рекомендацией короче, чем текст, вставляемый клавишей TAB","Следует ли подавлять предложения для текущего предложения","Находится ли курсор на фантомном тексте","Находится ли курсор в отступе","Есть ли в редакторе выделенный фрагмент","Находится ли курсор на встроенной правке","Видно ли встроенную правку","Должна ли вкладка переходить к встроенному редактированию.","Должна ли вкладка принимать встроенное редактирование.","Отображается ли в текущем редакторе кода предварительный просмотр встроенных параметров редактирования","Проверить этот аспект в представлении с поддержкой специальных возможностей ({0})","Здесь есть встроенные завершения","Предложение:","Значок для отображения подсказки следующего параметра.","Значок для отображения подсказки предыдущего параметра.","{0} ({1})","Назад","Далее","Перейти к","Принять","Отклонить","Показать развернуто","Показать свернутые","Отложить","Параметры",null,"Цвет фона для исходного текста во встроенных изменениях.","Цвет фона для измененного текста во встроенных изменениях.","Цвет фона для измененных строк в исходном тексте встроенных изменений.","Цвет наложения для измененного текста в исходном тексте встроенных изменений.","Цвет фона для измененных строк в измененном тексте встроенных изменений.","Цвет наложения для измененного текста в измененном тексте встроенных изменений.","Цвет переднего плана для основного встроенного индикатора редактирования.","Цвет границы для основного индикатора поля редактирования.","Цвет фона основного встроенного индикатора редактирования.","Цвет переднего плана для вторичного встроенного индикатора редактирования.","Цвет границы для индикатора вторичного встроенного редактирования.","Цвет фона для вторичного встроенного индикатора редактирования канавок.","Цвет переднего плана для индикатора успешного встроенного редактирования канавы.","Цвет границы индикатора выполненного встроенного редактирования.","Цвет фона для индикатора успешного встроенного редактирования канавы.","Цвет фона для индикатора встроенной правки.","Цвет границы для исходного текста во встроенных изменениях.","Цвет границы для измененного текста во встроенных изменениях.","Измененный цвет границы для мини-приложения встроенного редактирования, когда вкладка примет его.","Исходный цвет границы для мини-приложения встроенного редактирования поверх оригинального текста, когда вкладка примет его.","Заменить предыдущим значением","Заменить следующим значением","Вставить последнюю новую строку","Развернуть выделение строки","&&Копировать на строку выше","Копировать на строку &&ниже","&&Дублировать выбранное","Переместить на с&&троку выше","&&Переместить на строку ниже","Копировать строку сверху","Копировать строку снизу","Дублировать выбранное","Переместить строку вверх","Переместить строку вниз","Сортировка строк по возрастанию","Сортировка строк по убыванию","Удалить дублирующиеся строки","Обратить строки","Удалить конечные символы-разделители","Удалить строку","Увеличить отступ","Уменьшить отступ","Вставить строку выше","Вставить строку ниже","Удалить все слева","Удалить все справа","_Объединить строки","Транспонировать символы вокруг курсора","Преобразовать в верхний регистр","Преобразовать в нижний регистр","Преобразовать в заглавные буквы","Преобразовать в написание с подчеркиваниями",'Преобразовать в "верблюжий" стиль','Преобразовать в формат "КаждаяЧастьСПрописнойБуквы"',"Преобразовать в кебаб-кейс","Цвет фона при автоматическом переименовании типа редактором.","Запустить связанное редактирование","Не удалось открыть ссылку, так как она имеет неправильный формат: {0}","Не удалось открыть ссылку, у нее отсутствует целевой объект.","Выполнить команду","перейти по ссылке","Кнопка CMD и щелчок левой кнопкой мыши","Кнопка CTRL и щелчок левой кнопкой мыши","Кнопка OPTION и щелчок левой кнопкой мыши","Кнопка ALT и щелчок левой кнопкой мыши","Выполнение команды {0}","Открыть ссылку","Отображается ли сейчас в редакторе внутреннее сообщение","Курсор добавлен: {0}","Курсоры добавлены: {0}","Добавить курсор &&выше","Добавить курсор &&ниже","Добавить курсоры в &&окончания строк","Добавить &&следующее вхождение","Добавить &&предыдущее вхождение","Выбрать все &&вхождения","Фокусируется на следующем курсоре","Фокусируется на предыдущем курсоре","Добавить курсор выше","Добавить курсор ниже","Добавить курсоры к окончаниям строк","Добавить курсоры ниже","Добавить курсоры выше","Добавить выделенный фрагмент в следующее найденное совпадение","Добавить выделенный фрагмент в предыдущее найденное совпадение","Переместить последний выделенный фрагмент в следующее найденное совпадение","Переместить последний выделенный фрагмент в предыдущее найденное совпадение","Выбрать все вхождения найденных совпадений","Изменить все вхождения","Фокусировка на следующем курсоре","Фокусировка на предыдущем курсоре","Переключить подсказки к параметрам","Значок для отображения подсказки следующего параметра.","Значок для отображения подсказки предыдущего параметра.","{0}, указание","Цвет переднего плана активного элемента в указании параметра.","Встроен ли текущий редактор кода в окно просмотра","Закрыть","Цвет фона области заголовка быстрого редактора.","Цвет заголовка быстрого редактора.","Цвет сведений о заголовке быстрого редактора.","Цвет границ быстрого редактора и массива.","Цвет фона в списке результатов представления быстрого редактора.","Цвет переднего плана узлов строки в списке результатов быстрого редактора.","Цвет переднего плана узлов файла в списке результатов быстрого редактора.","Цвет фона выбранной записи в списке результатов быстрого редактора.","Цвет переднего плана выбранной записи в списке результатов быстрого редактора.","Цвет фона быстрого редактора.","Цвет фона поля в окне быстрого редактора.","Цвет фона закрепленной прокрутки в окне быстрого редактора.","Цвет фона переплета для закрепленной прокрутки в окне быстрого редактора.","Цвет выделения совпадений в списке результатов быстрого редактора.","Цвет выделения совпадений в быстром редакторе.","Граница выделения совпадений в быстром редакторе.","Цвет переднего плана для замещающего текста в редакторе.",null,"Использовать смещение с нулевой базой","Чтобы перейти к строке или к смещению, сначала откройте текстовый редактор.","Введите позицию символа для перехода к нему (от 0 до {0}).","Введите позицию символа для перехода к нему (от 1 до {0}).","Нажмите клавишу ВВОД, чтобы перейти к строке {0} в столбце {1}.","Введите номер строки для перехода к ней (от 1 до {0}).",'Нажмите клавишу ВВОД, чтобы перейти к строке {0}, или введите двоеточие ":" для добавления номера столбца.',"Нажмите клавишу ВВОД, чтобы перейти к строке {0}, или введите номер столбца (от 1 до {1}).","Нажмите клавишу ВВОД, чтобы перейти к строке {0} в столбце {1}.","Чтобы перейти к символу, сначала откройте текстовый редактор с символьной информацией.","Активный текстовый редактор не предоставляет символьную информацию.","Нет совпадающих символов редактора","Нет символов редактора","Открыть сбоку","Открыть внизу","символы ({0})","свойства ({0})","методы ({0})","функции ({0})","конструкторы ({0})","переменные ({0})","классы ({0})","структуры ({0})","события ({0})","операторы ({0})","интерфейсы ({0})","пространства имен ({0})","пакеты ({0})","параметры типа ({0})","модули ({0})","свойства ({0})","перечисления ({0})","элемента перечисления ({0})","строки ({0})","файлы ({0})","массивы ({0})","числа ({0})","логические значения ({0})","объекты ({0})","ключи ({0})","поля ({0})","константы ({0})","Не удается внести изменения во входные данные только для чтения","Не удается выполнить изменение в редакторе только для чтения","Результаты отсутствуют.","Произошла неизвестная ошибка при определении расположения после переименования",'Переименование "{0}" в "{1}"',"Переименование {0} в {1}","«{0}» успешно переименован в «{1}». Сводка: {2}","Операции переименования не удалось применить правки","Операции переименования не удалось вычислить правки","Включить/отключить возможность предварительного просмотра изменений перед переименованием","Переименовать символ","Фокусировка на следующем предложении по переименованию","Фокусировка на предыдущем предложении переименования","Отображается ли мини-приложение переименования входных данных","Фокусируется ли мини-приложение переименования входных данных","Нажмите {0} для переименования, {1} для просмотра.","Получено несколько ({0}) предложений по переименованию","Введите новое имя для входных данных и нажмите клавишу ВВОД для подтверждения.","Создать новые предложения имен","Отмена","&&Развернуть выделение","&&Сжать выделение","Развернуть выбранный фрагмент","Уменьшить выделенный фрагмент","Находится ли текущий редактор в режиме фрагментов","Указывает, существует ли следующая позиция табуляции в режиме фрагментов","Указывает, существует ли предыдущая позиция табуляции в режиме фрагментов","Перейти к следующему заполнителю...","воскресенье","понедельник","вторник","среда","четверг","пятница","суббота","Вс","Пн","Вт","Ср","Чт","Пт","Сб","Январь","Февраль","Март","Апрель","Май","Июнь","Июль","Август","Сентябрь","Октябрь","Ноябрь","Декабрь","Янв","Фев","Мар","Апр","Май","Июн","Июл","Авг","Сен","Окт","Ноя","Дек","&&Переключить закрепленную прокрутку редактора","Закрепленная прокрутка","&&Закрепленная прокрутка","&&Установить фокус на закрепленной прокрутке редактора","Переключить закрепленную прокрутку редактора","Включение или переключение закрепленной прокрутки редактора, которая показывает закрепленные области в верхней части области просмотра","Установить фокус на закрепленной прокрутке редактора","Выберите следующую линию закрепленной прокрутки редактора","Выбрать предыдущую строку закрепленной прокрутки","Перейти к строке закрепленной прокрутки, которая находится в фокусе","Выберите редактор","Находится ли какое-либо предложение в фокусе","Отображаются ли сведения о предложениях","Существует ли несколько предложений для выбора","Приводит ли вставка текущего предложения к изменению или все уже было введено","Вставляются ли предложения при нажатии клавиши ВВОД",'Есть ли у текущего предложения варианты поведения "вставка" и "замена"','Является ли текущее поведение поведением "вставка" или "замена"',"Поддерживает ли текущее предложение разрешение дополнительных сведений",'Принятие "{0}" привело к внесению дополнительных правок ({1})',"Вставить","Вставить","Заменить","Заменить","Вставить","Показать меньше","Показать больше","Переключить предложение","Сброс предложения размера мини-приложения","Цвет фона виджета подсказок.","Цвет границ виджета подсказок.","Цвет переднего плана мини-приложения предложений.","Цвет переднего плана выбранной записи в мини-приложении предложений.","Цвет переднего плана значка выбранной записи в мини-приложении предложений.","Фоновый цвет выбранной записи в мини-приложении предложений.","Цвет выделения соответствия в мини-приложении предложений.","Цвет совпадения выделяется в мини-приложениях предложений, когда элемент находится в фокусе.","Цвет переднего плана для состояния рекомендации мини-приложения.","Загрузка...","Предложения отсутствуют.","Предложить","{0}{1}{2} {3}","{0} {1}, {2}","{0}, {1}, {2}","{0}, {1}","{0}, документы: {1}","Закрыть","Загрузка...","Значок для получения дополнительных сведений в мини-приложении предложений.","Подробнее","Ключ контекста, который имеет значение true, когда в конце слова. Обратите внимание, что это определяется только при включении завершения табуляции","Цвет переднего плана для символов массива. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для логических символов. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов класса. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов цвета. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов константы. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов конструктора. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов перечислителя. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов члена перечислителя. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов события. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов поля. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов файла. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов папки. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов функции. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов интерфейса. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов ключа. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов ключевого слова. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов метода. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов модуля. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов пространства имен. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов NULL. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов числа. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов объекта. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов оператора. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов пакета. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов свойства. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов ссылки. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов фрагмента кода. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов строки. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов структуры. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов текста. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов типа параметров. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов единиц. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","Цвет переднего плана для символов переменной. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.","При нажатии клавиши TAB фокус перейдет на следующий элемент, который может получить фокус","Теперь при нажатии клавиши TAB будет вставлен символ табуляции","Переключение клавиши TAB перемещает фокус.","Определяет действие при нажатии клавиши TAB: перемещение фокуса по рабочему интерфейсу или вставка знака табуляции в текущем редакторе. Это также называется захватом фокуса на вкладках, навигацией по вкладкам или режимом фокусировки на вкладках.","Разработчик: принудительная повторная установка токенов","Закрыть баннер","Значок, отображаемый с предупреждением в редакторе расширений.","Этот документ содержит много нестандартных символов Юникода ASCII","Этот документ содержит много неоднозначных символов Юникода","Этот документ содержит много невидимых символов Юникода","Настройка параметров выделения Юникода","Символ {0} можно спутать с символом ASCII {1}, который чаще встречается в исходном коде.","Символ {0} можно спутать с символом {1}, который чаще встречается в исходном коде.","Символ {0} невидим.","Символ {0} не является базовым символом ASCII.","Настройка параметров","Отключить выделение в комментариях","Отключить выделение в строках","Отключить неоднозначное выделение","Отключить невидимое выделение","Отключить выделение, отличное от ASCII","Исключить {0} (невидимый символ) из выделения","Исключить {0} из выделения",'Разрешите символы Юникода, более распространенные в языке "{0}".',"Отключить выделение символов в комментариях","Отключить выделение символов в строках","Отключить выделение неоднозначных символов","Отключить выделение невидимых символов","Отключить выделение нестандартных символов ASCII","Показать параметры исключения","Необычные символы завершения строки","Обнаружены необычные символы завершения строки",`Файл "{0}" содержит один или несколько необычных символов завершения строки, таких как разделитель строк (LS) или разделитель абзацев (PS).\r
  14. \r
  15. Рекомендуется удалить их из файла. Удаление этих символов можно настроить с помощью параметра "editor.unusualLineTerminators".`,"&&Удалить необычные символы завершения строки","Пропустить","Цвет фона символа при доступе на чтение, например, при чтении переменной. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона для символа во время доступа на запись, например при записи в переменную. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона текстового вхождения символа. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже элементы оформления.","Цвет границы символа при доступе на чтение, например, при считывании переменной.","Цвет границы символа при доступе на запись, например, при записи переменной. ","Цвет границы текстового вхождения символа.","Цвет маркера обзорной линейки для выделения символов. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже элементы оформления.","Цвет маркера обзорной линейки для выделения символов доступа на запись. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет маркера обзорной линейки текстового вхождения символа. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже элементы оформления.","Перейти к следующему выделению символов","Перейти к предыдущему выделению символов","Включить или отключить выделение символов","Удалить слово","Ошибка в позиции","Ошибка","Предупреждение в позиции","Предупреждение","Ошибка в строке","Ошибка в строке","Предупреждение в строке","Предупреждение в строке","Сложенная область в строке","Свернуто","Точка останова в строке","Точка останова","Встроенная рекомендация в строке","Следующее предложение правки в строке","Следующее предложение правки","Быстрое исправление терминала","Быстрое исправление","Отладчик остановлен в точке останова","Точка останова","Отсутствие вложенных указаний в строке","Вложенные указания отсутствуют","Задача завершена","Задача завершена","Сбой задачи","Сбой задачи","Сбой команды терминала","Сбой команды","Команда терминала выполнена","Команда выполнена","Колокольчик терминала","Звонок терминала","Ячейка записной книжки выполнена","Ячейка записной книжки выполнена","Сбой ячейки записной книжки","Сбой ячейки записной книжки","Вставлена разностная строка","Удалена разностная строка","Изменена строка различий","Изменить измененный файл чата","Файл изменен из изменений чата","Отправлен запрос на чат","Отправлен запрос на чат","Получен ответ чата","Запрос на действие кода активирован","Запрос на действие кода активирован","Действие кода применено","Ход выполнения","Ход выполнения","Очистить","Очистка","Сохранить","Сохранить","Формат","Формат","Запись голоса начата","Запись голоса остановлена","Изменения сохранены","Изменения сохранены","Отменить изменения","Изменения отменены","Требуется действие пользователя чата","Требуется действие пользователя чата","Представление","Справка","Тест","Файл","Параметры","Разработчик","{0} ({1})","{0} ({1})",`{0}\r
  16. [{1}] {2}`,"{1} для {0}","{0} ({1})","Скрыть","Сбросить меню",'Скрыть "{0}"',"Настройка сочетания клавиш","{0}, чтобы применить, {1} для предварительного просмотра","{0}, чтобы применить","{0}, причина отключения: {1}","Мини-приложения действий","Цвет фона для переключаемых элементов действий на панели действий.","Отображается ли список мини-приложений действий","Скрыть мини-приложение действия","Выбрать предыдущее действие","Выбрать следующее действие","Принять выбранное действие","Предварительный просмотр выбранного действия","Переопределения конфигурации языка по умолчанию","Настройка переопределяемых параметров для {0}.","Настройка параметров редактора, переопределяемых для языка.","Этот параметр не поддерживает настройку для отдельных языков.","Настройка параметров редактора, переопределяемых для языка.","Этот параметр не поддерживает настройку для отдельных языков.","Не удается зарегистрировать пустое свойство",`Невозможно зарегистрировать "{0}". Оно соответствует шаблону свойства '\\\\[.*\\\\]$' для описания параметров редактора, определяемых языком. Используйте участие configurationDefaults.`,'Невозможно зарегистрировать "{0}". Это свойство уже зарегистрировано.','Невозможно зарегистрировать "{0}". Уже имеется регистрация {2} для связанной политики {1}.',"Команда, возвращающая сведения о ключах контекста","Пустое выражение ключа контекста",'Вы забыли записать выражение? Вы также можете поместить "false" или "true", чтобы всегда оценивать по значению false или true соответственно.','"in" после "not".','закрывающая круглая скобка ")"',"Непредвиденный маркер","Возможно, вы забыли поместить && или || перед маркером?","Неожиданный конец выражения","Возможно, вы забыли поместить ключ контекста?",`Ожидается: {0}\r
  17. Получено: "{1}".`,"Используется ли операционная система macOS","Используется ли операционная система Linux","Используется ли операционная система Windows","Является ли платформа браузерной","Используется ли операционная система macOS на платформе, отличной от браузерной","Используется ли операционная система IOS","Является ли платформа мобильным браузером","Тип качества VS Code","Находится ли фокус клавиатуры в поле ввода","Вы имели в виду {0}?","Вы имели в виду {0} или {1}?","Вы имели в виду {0}, {1} или {2}?","Вы забыли открыть или закрыть цитату?",'Вы забыли экранировать символ "/" (косая черта)? Чтобы экранировать, поместите перед символом две обратные косые черты, например "\\\\/".',"Отображаются ли предложения","Удерживайте клавишу {0}чтобы навести указатель мыши","Загрузка...","Была нажата клавиша {0}. Ожидание нажатия второй клавиши сочетания...","Была нажата клавиша ({0}). Ожидание нажатия следующей клавиши сочетания...","Сочетание клавиш ({0} и {1}) не является командой.","Сочетание клавиш ({0} и {1}) не является командой.","Рабочее место","Соответствует клавише CTRL в Windows и Linux и клавише COMMAND в macOS.","Соответствует клавише ALT в Windows и Linux и клавише OPTION в macOS.",'Модификатор, который будет использоваться для добавления элементов в деревьях и списках в элемент множественного выбора с помощью мыши (например, в проводнике, в открытых редакторах и в представлении scm). Жесты мыши "Открыть сбоку" (если они поддерживаются) будут изменены таким образом, чтобы они не конфликтовали с модификатором элемента множественного выбора.',"Управляет тем, как открывать элементы в деревьях и списках с помощью мыши (если поддерживается). Обратите внимание, что этот параметр может игнорироваться в некоторых деревьях и списках, если он не применяется к ним.","Определяет, поддерживают ли горизонтальную прокрутку списки и деревья на рабочем месте. Предупреждение! Включение этого параметра может повлиять на производительность.","Определяет, следует ли щелкать полосу прокрутки постранично.","Определяет отступ для дерева в пикселях.","Определяет, нужно ли в дереве отображать направляющие отступа.","Управляет тем, используется ли плавная прокрутка для списков и деревьев.","Множитель, используемый для параметров deltaX и deltaY событий прокрутки колесика мыши.","Коэффициент увеличения скорости прокрутки при нажатии клавиши ALT.","При поиске необходимо выделять элементы. При дальнейшей навигации вверх и вниз выполняется обход только выделенных элементов.","Фильтруйте элементы при поиске.","Управляет режимом поиска по умолчанию для списков и деревьев в Workbench.","Про простой навигации с клавиатуры выбираются элементы, соответствующие вводимым с клавиатуры данным. Сопоставление осуществляется только по префиксам.","Функция подсветки навигации с клавиатуры выделяет элементы, соответствующие вводимым с клавиатуры данным. При дальнейшей навигации вверх и вниз выполняется обход только выделенных элементов.","Фильтр навигации с клавиатуры позволяет отфильтровать и скрыть все элементы, не соответствующие вводимым с клавиатуры данным.","Управляет стилем навигации с клавиатуры для списков и деревьев в Workbench. Доступен простой режим, режим выделения и режим фильтрации.",'Вместо этого используйте "workbench.list.defaultFindMode" и "workbench.list.typeNavigationMode".',"Использовать нечеткое соответствие при поиске.","Использовать непрерывное сопоставление при поиске.","Управляет типом сопоставления, используемым при поиске списков и деревьев в Workbench.","Управляет тем, как папки дерева разворачиваются при нажатии на имена папок. Обратите внимание, что этот параметр может игнорироваться в некоторых деревьях и списках, если он не применяется к ним.","Определяет, включена ли закрепленная прокрутка в деревьях.","Управляет числом прикрепленных элементов, отображаемых в дереве, когда включен параметр {0}.",'Управляет работой навигации по типам в списках и деревьях в рабочей среде. Если установлено значение "trigger", навигация по типу начинается после запуска команды "list.triggerTypeNavigation".',"Ошибка","Предупреждение","Информация","Сообщения об ошибках","Предупреждения","Информационные сообщения",'Проблемы приостановлены по следующей причине: "{0}"','Проблемы приостановлены по следующим причинам: "{0}" и еще {1}',"недавно использованные","похожие команды","часто используемые","другие команды","похожие команды","{0}, {1}",'Команда "{0}" привела к ошибке',"{0}, {1}","Находится ли фокус клавиатуры внутри элемента управления быстрым вводом","Выравнивание быстрого ввода","Тип видимого в данный момент быстрого ввода","Находится ли курсор при быстром вводе в конце поля ввода","Назад","Нажмите клавишу ВВОД, чтобы подтвердить введенные данные, или ESCAPE для отмены","{0} / {1}","Введите текст, чтобы уменьшить число результатов.","ОК","{0} (нажмите клавишу ВВОД, чтобы подтвердить введенные данные, или ESCAPE для отмены)","Используется в контексте любого типа быстрого ввода. Если вы измените одну комбинацию клавиш для этой команды, вам также следует изменить все остальные комбинации клавиш (варианты модификаторов) этой команды.","Используется в контексте быстрого выбора. Если вы измените одну комбинацию клавиш для этой команды, вам также следует изменить все остальные комбинации клавиш (варианты модификаторов) этой команды.","Если мы находимся в режиме быстрого доступа, это приведет к переходу к следующему элементу. Если мы не находимся в режиме быстрого доступа, это приведет к переходу к следующему разделителю.","Если мы находимся в режиме быстрого доступа, это приведет к переходу к предыдущему элементу. Если мы не находимся в режиме быстрого доступа, это приведет к переходу к предыдущему разделителю.","Используется в контексте быстрого ввода. Если вы измените одну комбинацию клавиш для этой команды, вам также следует изменить все остальные комбинации клавиш (варианты модификаторов) этой команды.","Переключить все флажки","Результаты: {0}","{0} выбрано","ОК","Другой","Назад ({0})","Назад","Быстрый ввод",'Щелкните, чтобы выполнить команду "{0}"',"Быстрое дерево","Общий цвет переднего плана. Этот цвет используется, только если его не переопределит компонент.","Общий цвет переднего плана для отключенных элементов. Этот цвет используется только в том случае, если он не переопределен компонентом.","Общий цвет переднего плана для сообщений об ошибках. Этот цвет используется только если его не переопределяет компонент.","Цвет текста элемента, содержащего пояснения, например, для метки.","Цвет по умолчанию для значков на рабочем месте.","Общий цвет границ для элементов с фокусом. Этот цвет используется только в том случае, если не переопределен в компоненте.","Дополнительная граница вокруг элементов, которая отделяет их от других элементов для улучшения контраста.","Дополнительная граница вокруг активных элементов, которая отделяет их от других элементов для улучшения контраста.","Цвет фона выделенного текста в рабочей области (например, в полях ввода или в текстовых полях). Не применяется к выделенному тексту в редакторе.","Цвет переднего плана для ссылок в тексте.","Цвет переднего плана для ссылок в тексте при щелчке и при наведении курсора мыши.","Цвет для разделителей текста.","Цвет текста фиксированного формата.","Цвет фона для сегментов предварительно отформатированного текста.","Цвет фона для блоков с цитатами в тексте.","Цвет границ для блоков с цитатами в тексте.","Цвет фона для программного кода в тексте.","Цвет переднего плана на диаграммах.","Цвет горизонтальных линий на диаграммах.","Красный цвет, используемый в визуализациях диаграмм.","Синий цвет, используемый в визуализациях диаграмм.","Желтый цвет, используемый в визуализациях диаграмм.","Оранжевый цвет, используемый в визуализациях диаграмм.","Зеленый цвет, используемый в визуализациях диаграмм.","Лиловый цвет, используемый в визуализациях диаграмм.","Цвет фона редактора.","Цвет переднего плана редактора по умолчанию.","Цвет фона закрепленной прокрутки в редакторе","Цвет фона переплета для закрепленной прокрутки в редакторе","Цвет фона закрепленной прокрутки при наведении курсора мыши в редакторе","Цвет тени закрепленной прокрутки в редакторе"," Цвет тени закрепленной прокрутки в редакторе","Цвет фона виджетов редактора, таких как найти/заменить.",'Цвет переднего плана мини-приложений редактора, таких как "Поиск/замена".',"Цвет границы мини-приложений редактора. Этот цвет используется только в том случае, если у мини-приложения есть граница и если этот цвет не переопределен мини-приложением.","Цвет границы панели изменения размера мини-приложений редактора. Этот цвет используется только в том случае, если у мини-приложения есть граница для изменения размера и если этот цвет не переопределен мини-приложением.","Цвет фона для текста ошибки в редакторе. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет волнистой линии для выделения ошибок в редакторе.","Если задано, цвет двойного подчеркивания ошибок в редакторе.","Цвет фона для текста предупреждения в редакторе. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет волнистой линии для выделения предупреждений в редакторе.","Если задано, цвет двойного подчеркивания предупреждений в редакторе.","Цвет фона для текста информационного сообщения в редакторе. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет волнистой линии для выделения информационных сообщений в редакторе.","Если задано, цвет двойного подчеркивания информационных сообщений в редакторе.","Цвет волнистой линии для выделения подсказок в редакторе.","Если задано, цвет двойного подчеркивания указаний в редакторе.","Цвет активных ссылок.","Цвет выделения редактора.","Цвет выделенного текста в режиме высокого контраста.","Цвет выделения в неактивном редакторе. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет для областей, содержимое которых совпадает с выбранным фрагментом. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет границы регионов с тем же содержимым, что и в выделении.","Цвет границы для композиции IME.","Цвет текущего поиска совпадений.","Цвет текста текущего результата поиска.","Цвет других совпадений при поиске. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет переднего плана других результатов поиска.","Цвет диапазона, ограничивающего поиск. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет границы текущего результата поиска.","Цвет границы других результатов поиска.","Цвет границы для диапазона, ограничивающего поиск. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Выделение под словом, для которого отображается меню при наведении курсора. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона при наведении указателя на редактор.","Цвет переднего плана для наведения указателя на редактор.","Цвет границ при наведении указателя на редактор.","Цвет фона строки состояния при наведении в редакторе.","Цвет переднего плана встроенных указаний","Цвет фона встроенных указаний","Цвет переднего плана встроенных указаний для шрифтов","Цвет фона встроенных указаний для шрифтов","Цвет переднего плана встроенных указаний для параметров","Цвет фона встроенных указаний для параметров","Цвет, используемый для значка действий в меню лампочки.","Цвет, используемый для значка действий автоматического исправления в меню лампочки.","Цвет, используемый для значка ИИ с лампочкой.","Цвет фона выделения в позиции табуляции фрагмента.","Цвет границы выделения в позиции табуляции фрагмента.","Цвет фона выделения в последней позиции табуляции фрагмента.","Выделение цветом границы в последней позиции табуляции фрагмента.","Цвет фона для вставленного текста. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона для удаленного текста. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона для вставленных строк. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона для удаленных строк. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет фона для поля, где вставлены строки.","Цвет фона для поля, где удалены строки.","Передний план обзорной линейки различий для вставленного содержимого.","Передний план обзорной линейки различий для удаленного содержимого.","Цвет контура для добавленных строк.","Цвет контура для удаленных строк.","Цвет границы между двумя текстовыми редакторами.","Цвет диагональной заливки для редактора несовпадений. Диагональная заливка используется в размещаемых рядом представлениях несовпадений.","Цвет фона неизмененных блоков в редакторе несовпадений.","Цвет переднего плана неизмененных блоков в редакторе несовпадений.","Цвет фона неизмененного кода в редакторе несовпадений.",'Цвет тени мини-приложений редактора, таких как "Найти/заменить".','Цвет границы мини-приложений редактора, таких как "Найти/заменить".',"Фон панели инструментов при наведении указателя мыши на действия","Контур панели инструментов при наведении указателя мыши на действия","Фон панели инструментов при удержании указателя мыши над действиями","Цвет элементов навигации, находящихся в фокусе.","Фоновый цвет элементов навигации.","Цвет элементов навигации, находящихся в фокусе.","Цвет выделенных элементов навигации.","Фоновый цвет средства выбора элементов навигации.","Текущий цвет фона заголовка при внутренних конфликтах слияния. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Фон текущего содержимого при внутренних конфликтах слияния. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Фон входящего заголовка при внутренних конфликтах объединения. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Фон входящего содержимого при внутренних конфликтах слияния. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Фон заголовка общего предка во внутренних конфликтах слияния. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Фон содержимого общего предка во внутренних конфликтах слияния. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет границы заголовков и разделителя во внутренних конфликтах слияния.","Цвет переднего плана линейки текущего окна во внутренних конфликтах слияния.","Цвет переднего плана линейки входящего окна во внутренних конфликтах слияния.","Цвет переднего плана для обзорной линейки для общего предка во внутренних конфликтах слияния. ","Цвет маркера обзорной линейки для совпадений при поиске. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Маркер обзорной линейки для выделения выбранного фрагмента. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.","Цвет, используемый для значка ошибки, указывающего на наличие проблем.","Цвет, используемый для предупреждающего значка, указывающего на наличие проблем.","Цвет, используемый для информационного значка, указывающего на наличие проблем.","Фон поля ввода.","Передний план поля ввода.","Граница поля ввода.","Цвет границ активированных параметров в полях ввода.","Цвет фона активированных параметров в полях ввода.","Цвет фонового наведения параметров в полях ввода.","Цвет переднего плана активированных параметров в полях ввода.","Цвет фона поясняющего текста в элементе ввода.",'Фоновый цвет проверки ввода для уровня серьезности "Сведения".','Цвет переднего плана области проверки ввода для уровня серьезности "Сведения".','Цвет границы проверки ввода для уровня серьезности "Сведения".','Фоновый цвет проверки ввода для уровня серьезности "Предупреждение".','Цвет переднего плана области проверки ввода для уровня серьезности "Предупреждение".','Цвет границы проверки ввода для уровня серьезности "Предупреждение".','Фоновый цвет проверки ввода для уровня серьезности "Ошибка".','Цвет переднего плана области проверки ввода для уровня серьезности "Ошибка".','Цвет границы проверки ввода для уровня серьезности "Ошибка".',"Фон раскрывающегося списка.","Цвет фона раскрывающегося списка.","Передний план раскрывающегося списка.","Граница раскрывающегося списка.","Цвет переднего плана кнопки.","Цвет разделителя кнопок.","Цвет фона кнопки.","Цвет фона кнопки при наведении.","Цвет границы кнопки.","Цвет переднего плана вторичной кнопки.","Цвет фона вторичной кнопки.","Цвет фона вторичной кнопки при наведении курсора мыши.","Цвет переднего плана активного переключателя.","Цвет фона активного переключателя.","Цвет границы активного переключателя.","Цвет переднего плана неактивного переключателя.","Цвет фона неактивного переключателя.","Цвет границы неактивного переключателя.","Цвет фона неактивного переключателя при наведении указателя мыши.","Цвет фона мини-приложения флажка.","Цвет фона виджета флажка при выборе элемента, в котором он находится.","Цвет переднего плана мини-приложения флажка.","Цвет границы мини-приложения флажка.","Цвет границы виджета флажка, когда выбран элемент, в котором он находится.","Фон отключенного флажка.","Передний план отключенного флажка.","Цвет фона метки настраиваемого сочетания клавиш. Метка настраиваемого сочетания клавиш используется для обозначения сочетания клавиш.","Цвет переднего плана метки настраиваемого сочетания клавиш. Метка настраиваемого сочетания клавиш используется для обозначения сочетания клавиш.","Цвет границы метки настраиваемого сочетания клавиш. Метка настраиваемого сочетания клавиш используется для обозначения сочетания клавиш.","Цвет нижней границы метки настраиваемого сочетания клавиш. Метка настраиваемого сочетания клавиш используется для обозначения сочетания клавиш.","Фоновый цвет находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет переднего плана находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет контура находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет контура находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен и выбран. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Фоновый цвет выбранного элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет переднего плана выбранного элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет переднего плана значка списка или дерева для выбранного элемента, когда список или дерево активны. Активный список или дерево находятся в фокусе клавиатуры, а неактивный — нет.","Фоновый цвет выбранного элемента List/Tree, когда элемент List/Tree неактивен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет текста выбранного элемента List/Tree, когда элемент List/Tree неактивен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет переднего плана значка списка или дерева для выбранного элемента, когда список или дерево неактивны. Активный список или дерево находятся в фокусе клавиатуры, а неактивный — нет.","Фоновый цвет находящегося в фокусе элемента List/Tree, когда элемент List/Tree не активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Цвет контура находящегося в фокусе элемента List/Tree, когда элемент List/Tree не активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.","Фоновый цвет элементов List/Tree при наведении курсора мыши.","Цвет переднего плана элементов List/Tree при наведении курсора мыши.","Перетаскивание фона списка или дерева при перемещении элементов над другими элементами с помощью мыши.","Цвет границы перетаскивания списка/дерева при перемещении элементов между элементами с помощью мыши.","Цвет переднего плана для выделения соответствия при поиске по элементу List/Tree.","Цвет переднего плана для выделения соответствия выделенных элементов при поиске по элементу List/Tree.","Цвет переднего плана списка/дерева для недопустимых элементов, например, для неразрешенного корневого узла в проводнике.","Цвет переднего плана элементов списка, содержащих ошибки.","Цвет переднего плана элементов списка, содержащих предупреждения.","Цвет фона для мини-приложения фильтра типов в списках и деревьях.","Цвет контура для мини-приложения фильтра типов в списках и деревьях.","Цвет контура для мини-приложения фильтра типов в списках и деревьях при отсутствии совпадений.","Цвет тени для мини-приложения фильтра типов в списках и деревьях.","Цвет фона для отфильтрованного совпадения.","Цвет границы для отфильтрованного совпадения.","Цвет переднего плана в списке или дереве для элементов, выделение которых уменьшено.","Цвет штриха дерева для направляющих отступа.","Цвет штриха дерева для неактивных направляющих отступа.","Цвет границы таблицы между столбцами.","Цвет фона для нечетных строк таблицы.","Цвет фона списка действий.","Цвет переднего плана списка действий.","Цвет переднего плана списка действий для элемента, на котором находится фокус.","Цвет фона списка действий для элемента, на котором находится фокус.","Цвет границ меню.","Цвет переднего плана пунктов меню.","Цвет фона пунктов меню.","Цвет переднего плана выбранного пункта меню в меню.","Цвет фона для выбранного пункта в меню.","Цвет границы для выбранного пункта в меню.","Цвет разделителя меню в меню.","Цвет маркера мини-карты для поиска совпадений.","Цвет маркера мини-карты для повторяющихся выделений редактора.","Цвет маркера мини-карты для выбора редактора.","Цвет маркера на мини-карте для информации.","Цвет маркера миникарты для предупреждений.","Цвет маркера миникарты для ошибок.","Цвет фона мини-карты.",'Прозрачность элементов переднего плана, отображаемая га мини-карте. Например, "#000000c0" отображает элементы с прозрачностью 75%.',"Цвет фона ползунка мини-карты.","Цвет фона ползунка мини-карты при наведении на него указателя.","Цвет фона ползунка мини-карты при его щелчке.","Цвет границы активных лент.","Цвет фона бэджа. Бэджи - небольшие информационные элементы, отображающие количество, например, результатов поиска.","Цвет текста бэджа. Бэджи - небольшие информационные элементы, отображающие количество, например, результатов поиска.","Цвет переднего плана значка предупреждения об активности","Цвет фона значка предупреждения об активности","Цвет переднего плана значка активности при ошибке","Цвет фона значка активности при ошибке","Цвет тени полосы прокрутки, которая свидетельствует о том, что содержимое прокручивается.","Цвет фона для ползунка полосы прокрутки.","Цвет фона ползунка полосы прокрутки при наведении курсора.","Цвет фона ползунка полосы прокрутки при щелчке по нему.","Цвет фона дорожки полосы прокрутки.","Цвет фона индикатора выполнения, который может отображаться для длительных операций.","Цвет линии для диаграммы.","Цвет оси для диаграммы.","Направляющие для диаграммы.","Цвет фона для средства быстрого выбора. Мини-приложение быстрого выбора является контейнером для таких средств выбора, как палитра команд.","Цвет переднего плана для средства быстрого выбора. Мини-приложение быстрого выбора является контейнером для таких средств выбора, как палитра команд.","Цвет фона для заголовка средства быстрого выбора. Мини-приложение быстрого выбора является контейнером для таких средств выбора, как палитра команд.","Цвет средства быстрого выбора для группировки меток.","Цвет средства быстрого выбора для группировки границ.","Рекомендуется использовать quickInputList.focusBackground.","Цвет переднего плана средства быстрого выбора для элемента, на котором находится фокус.","Цвет переднего плана значка средства быстрого выбора для элемента, на котором находится фокус.","Цвет фона средства быстрого выбора для элемента, на котором находится фокус.","Цвет текста в поиске сообщения завершения вьюлета.","Цвет соответствий для запроса в редакторе поиска.","Цвет границы для соответствующих запросов в редакторе поиска.","Этот цвет должен быть прозрачным, иначе он будет скрывать содержимое","Использовать цвет по умолчанию.","Идентификатор шрифта должен содержать только буквы, цифры, символы подчеркивания и дефисы.","Идентификатор используемого шрифта. Если параметр не задан, используется шрифт, определенный первым.","Символ шрифта, связанный с определением значка.","Значок для действия закрытия в мини-приложениях.","Значок для перехода к предыдущему расположению в редакторе.","Значок для перехода к следующему расположению в редакторе.","Следующие файлы были закрыты и изменены на диске: {0}.","Следующие файлы были изменены несовместимым образом: {0}.",'Не удалось отменить "{0}" для всех файлов. {1}','Не удалось отменить "{0}" для всех файлов. {1}','Не удалось отменить операцию "{0}" для всех файлов, так как были внесены изменения в {1}','Не удалось отменить действие "{0}" для всех файлов, так как в {1} уже выполняется операция отмены или повтора действия','Не удалось отменить действие "{0}" для всех файлов, так как уже выполнялась операция отмены или повтора действия','Вы хотите отменить "{0}" для всех файлов?',"&&Отменить действие в файлах {0}","Отменить этот &&файл",'Не удалось отменить действие "{0}", так как уже выполняется операция отмены или повтора действия','Вы хотите отменить "{0}"?',"&&Да","Нет",'Не удалось повторить операцию "{0}" для всех файлов. {1}','Не удалось повторить операцию "{0}" для всех файлов. {1}','Не удалось повторить операцию "{0}" для всех файлов, так как были внесены изменения в {1}','Не удалось повторить действие "{0}" для всех файлов, так как для {1} уже выполняется операция отмены или повтора действия.','Не удалось повторить действие "{0}" для всех файлов, так как уже выполнялась операция отмены или повтора действия','Не удалось повторить действие "{0}", так как уже выполняется операция отмены или повтора действия',"Рабочая область кода"],globalThis._VSCODE_NLS_LANGUAGE="ru"),e}var r=i();return n.getDefaultExportFromCjs(r)}));

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.