frodovdr/node-red
1
0
Fork 0
mirror of https://github.com/node-red/node-red.git synced 2023-10-10 13:36:53 +02:00
Code Issues Releases Wiki Activity

Merge pull request #4089 from Steve-Mcl/update-monaco-and-typings

Browse Source 
Update-monaco-and-typings
This commit is contained in:
Nick O'Leary 2023-03-03 11:52:13 +00:00 committed by GitHub
commit 2ed17f0fff
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
79 changed files with 34046 additions and 8107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Gruntfile.js
View File

@ -408,7 +408,7 @@ module.exports = function(grunt) {
{
cwd: 'packages/node_modules/@node-red/editor-client/src',
src: [
'types/node/*.ts',
'types/node/**/*.ts',
'types/node-red/*.ts',
],
expand: true,

10
packages/node_modules/@node-red/editor-client/src/js/ui/editors/code-editors/monaco.js vendored
View File

@ -59,18 +59,21 @@ RED.editor.codeEditor.monaco = (function() {
//TODO: get from externalModules.js For now this is enough for feature parity with ACE (and then some).
const knownModules = {
"assert": {package: "node", module: "assert", path: "node/assert.d.ts" },
"assert/strict": {package: "node", module: "assert/strict", path: "node/assert/strict.d.ts" },
"async_hooks": {package: "node", module: "async_hooks", path: "node/async_hooks.d.ts" },
"buffer": {package: "node", module: "buffer", path: "node/buffer.d.ts" },
"child_process": {package: "node", module: "child_process", path: "node/child_process.d.ts" },
"cluster": {package: "node", module: "cluster", path: "node/cluster.d.ts" },
"console": {package: "node", module: "console", path: "node/console.d.ts" },
"constants": {package: "node", module: "constants", path: "node/constants.d.ts" },
"crypto": {package: "node", module: "crypto", path: "node/crypto.d.ts" },
"dgram": {package: "node", module: "dgram", path: "node/dgram.d.ts" },
"diagnostics_channel.d": {package: "node", module: "diagnostics_channel", path: "node/diagnostics_channel.d.ts" },
"dns": {package: "node", module: "dns", path: "node/dns.d.ts" },
"dns/promises": {package: "node", module: "dns/promises", path: "node/dns/promises.d.ts" },
"domain": {package: "node", module: "domain", path: "node/domain.d.ts" },
"events": {package: "node", module: "events", path: "node/events.d.ts" },
"fs": {package: "node", module: "fs", path: "node/fs.d.ts" },
"fs/promises": {package: "node", module: "fs/promises", path: "node/fs/promises.d.ts" },
"globals": {package: "node", module: "globals", path: "node/globals.d.ts" },
"http": {package: "node", module: "http", path: "node/http.d.ts" },
"http2": {package: "node", module: "http2", path: "node/http2.d.ts" },
@ -84,8 +87,13 @@ RED.editor.codeEditor.monaco = (function() {
"querystring": {package: "node", module: "querystring", path: "node/querystring.d.ts" },
"readline": {package: "node", module: "readline", path: "node/readline.d.ts" },
"stream": {package: "node", module: "stream", path: "node/stream.d.ts" },
"stream/consumers": {package: "node", module: "stream/consumers", path: "node/stream/consumers.d.ts" },
"stream/promises": {package: "node", module: "stream/promises", path: "node/stream/promises.d.ts" },
"stream/web": {package: "node", module: "stream/web", path: "node/stream/web.d.ts" },
"string_decoder": {package: "node", module: "string_decoder", path: "node/string_decoder.d.ts" },
"test": {package: "node", module: "test", path: "node/test.d.ts" },
"timers": {package: "node", module: "timers", path: "node/timers.d.ts" },
"timers/promises": {package: "node", module: "timers/promises", path: "node/timers/promises.d.ts" },
"tls": {package: "node", module: "tls", path: "node/tls.d.ts" },
"trace_events": {package: "node", module: "trace_events", path: "node/trace_events.d.ts" },
"tty": {package: "node", module: "tty", path: "node/tty.d.ts" },

962
packages/node_modules/@node-red/editor-client/src/types/node/assert.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

11
packages/node_modules/@node-red/editor-client/src/types/node/assert/strict.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
declare module 'assert/strict' {
import { strict } from 'node:assert';
export = strict;
}
declare module 'node:assert/strict' {
import { strict } from 'node:assert';
export = strict;
}

456
packages/node_modules/@node-red/editor-client/src/types/node/async_hooks.d.ts vendored
View File

@ -2,18 +2,49 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* Async Hooks module: https://nodejs.org/api/async_hooks.html
* The `async_hooks` module provides an API to track asynchronous resources. It
* can be accessed using:
*
* ```js
* import async_hooks from 'async_hooks';
* ```
* @experimental
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/async_hooks.js)
*/
declare module 'async_hooks' {
/**
* Returns the asyncId of the current execution context.
* ```js
* import { executionAsyncId } from 'async_hooks';
*
* console.log(executionAsyncId()); // 1 - bootstrap
* fs.open(path, 'r', (err, fd) => {
* console.log(executionAsyncId()); // 6 - open()
* });
* ```
*
* The ID returned from `executionAsyncId()` is related to execution timing, not
* causality (which is covered by `triggerAsyncId()`):
*
* ```js
* const server = net.createServer((conn) => {
* // Returns the ID of the server, not of the new connection, because the
* // callback runs in the execution scope of the server's MakeCallback().
* async_hooks.executionAsyncId();
*
* }).listen(port, () => {
* // Returns the ID of a TickObject (process.nextTick()) because all
* // callbacks passed to .listen() are wrapped in a nextTick().
* async_hooks.executionAsyncId();
* });
* ```
*
* Promise contexts may not get precise `executionAsyncIds` by default.
* See the section on `promise execution tracking`.
* @since v8.1.0
* @return The `asyncId` of the current execution context. Useful to track when something calls.
*/
function executionAsyncId(): number;
/**
* The resource representing the current execution.
* Useful to store data within the resource.
*
* Resource objects returned by `executionAsyncResource()` are most often internal
* Node.js handle objects with undocumented APIs. Using any functions or properties
* on the object is likely to crash your application and should be avoided.
@ -21,14 +52,70 @@ declare module 'async_hooks' {
* Using `executionAsyncResource()` in the top-level execution context will
* return an empty object as there is no handle or request object to use,
* but having an object representing the top-level can be helpful.
*
* ```js
* import { open } from 'fs';
* import { executionAsyncId, executionAsyncResource } from 'async_hooks';
*
* console.log(executionAsyncId(), executionAsyncResource()); // 1 {}
* open(new URL(import.meta.url), 'r', (err, fd) => {
* console.log(executionAsyncId(), executionAsyncResource()); // 7 FSReqWrap
* });
* ```
*
* This can be used to implement continuation local storage without the
* use of a tracking `Map` to store the metadata:
*
* ```js
* import { createServer } from 'http';
* import {
* executionAsyncId,
* executionAsyncResource,
* createHook
* } from 'async_hooks';
* const sym = Symbol('state'); // Private symbol to avoid pollution
*
* createHook({
* init(asyncId, type, triggerAsyncId, resource) {
* const cr = executionAsyncResource();
* if (cr) {
* resource[sym] = cr[sym];
* }
* }
* }).enable();
*
* const server = createServer((req, res) => {
* executionAsyncResource()[sym] = { state: req.url };
* setTimeout(function() {
* res.end(JSON.stringify(executionAsyncResource()[sym]));
* }, 100);
* }).listen(3000);
* ```
* @since v13.9.0, v12.17.0
* @return The resource representing the current execution. Useful to store data within the resource.
*/
function executionAsyncResource(): object;
/**
* Returns the ID of the resource responsible for calling the callback that is currently being executed.
* ```js
* const server = net.createServer((conn) => {
* // The resource that caused (or triggered) this callback to be called
* // was that of the new connection. Thus the return value of triggerAsyncId()
* // is the asyncId of "conn".
* async_hooks.triggerAsyncId();
*
* }).listen(port, () => {
* // Even though all callbacks passed to .listen() are wrapped in a nextTick()
* // the callback itself exists because the call to the server's .listen()
* // was made. So the return value would be the ID of the server.
* async_hooks.triggerAsyncId();
* });
* ```
*
* Promise contexts may not get valid `triggerAsyncId`s by default. See
* the section on `promise execution tracking`.
* @return The ID of the resource responsible for calling the callback that is currently being executed.
*/
function triggerAsyncId(): number;
interface HookCallbacks {
/**
* Called when a class is constructed that has the possibility to emit an asynchronous event.
@ -38,73 +125,133 @@ declare module 'async_hooks' {
* @param resource reference to the resource representing the async operation, needs to be released during destroy
*/
init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
/**
* When an asynchronous operation is initiated or completes a callback is called to notify the user.
* The before callback is called just before said callback is executed.
* @param asyncId the unique identifier assigned to the resource about to execute the callback.
*/
before?(asyncId: number): void;
/**
* Called immediately after the callback specified in before is completed.
* @param asyncId the unique identifier assigned to the resource which has executed the callback.
*/
after?(asyncId: number): void;
/**
* Called when a promise has resolve() called. This may not be in the same execution id
* as the promise itself.
* @param asyncId the unique id for the promise that was resolve()d.
*/
promiseResolve?(asyncId: number): void;
/**
* Called after the resource corresponding to asyncId is destroyed
* @param asyncId a unique ID for the async resource
*/
destroy?(asyncId: number): void;
}
interface AsyncHook {
/**
* Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.
*/
enable(): this;
/**
* Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
*/
disable(): this;
}
/**
* Registers functions to be called for different lifetime events of each async operation.
* @param options the callbacks to register
* @return an AsyncHooks instance used for disabling and enabling hooks
* Registers functions to be called for different lifetime events of each async
* operation.
*
* The callbacks `init()`/`before()`/`after()`/`destroy()` are called for the
* respective asynchronous event during a resource's lifetime.
*
* All callbacks are optional. For example, if only resource cleanup needs to
* be tracked, then only the `destroy` callback needs to be passed. The
* specifics of all functions that can be passed to `callbacks` is in the `Hook Callbacks` section.
*
* ```js
* import { createHook } from 'async_hooks';
*
* const asyncHook = createHook({
* init(asyncId, type, triggerAsyncId, resource) { },
* destroy(asyncId) { }
* });
* ```
*
* The callbacks will be inherited via the prototype chain:
*
* ```js
* class MyAsyncCallbacks {
* init(asyncId, type, triggerAsyncId, resource) { }
* destroy(asyncId) {}
* }
*
* class MyAddedCallbacks extends MyAsyncCallbacks {
* before(asyncId) { }
* after(asyncId) { }
* }
*
* const asyncHook = async_hooks.createHook(new MyAddedCallbacks());
* ```
*
* Because promises are asynchronous resources whose lifecycle is tracked
* via the async hooks mechanism, the `init()`, `before()`, `after()`, and`destroy()` callbacks _must not_ be async functions that return promises.
* @since v8.1.0
* @param callbacks The `Hook Callbacks` to register
* @return Instance used for disabling and enabling hooks
*/
function createHook(options: HookCallbacks): AsyncHook;
function createHook(callbacks: HookCallbacks): AsyncHook;
interface AsyncResourceOptions {
/**
* The ID of the execution context that created this async event.
* @default executionAsyncId()
*/
triggerAsyncId?: number | undefined;
/**
* Disables automatic `emitDestroy` when the object is garbage collected.
* This usually does not need to be set (even if `emitDestroy` is called
* manually), unless the resource's `asyncId` is retrieved and the
* sensitive API's `emitDestroy` is called with it.
* @default false
*/
requireManualDestroy?: boolean | undefined;
/**
* The ID of the execution context that created this async event.
* @default executionAsyncId()
*/
triggerAsyncId?: number | undefined;
/**
* Disables automatic `emitDestroy` when the object is garbage collected.
* This usually does not need to be set (even if `emitDestroy` is called
* manually), unless the resource's `asyncId` is retrieved and the
* sensitive API's `emitDestroy` is called with it.
* @default false
*/
requireManualDestroy?: boolean | undefined;
}
/**
* The class AsyncResource was designed to be extended by the embedder's async resources.
* Using this users can easily trigger the lifetime events of their own resources.
* The class `AsyncResource` is designed to be extended by the embedder's async
* resources. Using this, users can easily trigger the lifetime events of their
* own resources.
*
* The `init` hook will trigger when an `AsyncResource` is instantiated.
*
* The following is an overview of the `AsyncResource` API.
*
* ```js
* import { AsyncResource, executionAsyncId } from 'async_hooks';
*
* // AsyncResource() is meant to be extended. Instantiating a
* // new AsyncResource() also triggers init. If triggerAsyncId is omitted then
* // async_hook.executionAsyncId() is used.
* const asyncResource = new AsyncResource(
* type, { triggerAsyncId: executionAsyncId(), requireManualDestroy: false }
* );
*
* // Run a function in the execution context of the resource. This will
* // * establish the context of the resource
* // * trigger the AsyncHooks before callbacks
* // * call the provided function `fn` with the supplied arguments
* // * trigger the AsyncHooks after callbacks
* // * restore the original execution context
* asyncResource.runInAsyncScope(fn, thisArg, ...args);
*
* // Call AsyncHooks destroy callbacks.
* asyncResource.emitDestroy();
*
* // Return the unique ID assigned to the AsyncResource instance.
* asyncResource.asyncId();
*
* // Return the trigger ID for the AsyncResource instance.
* asyncResource.triggerAsyncId();
* ```
*/
class AsyncResource {
/**
@ -114,115 +261,236 @@ declare module 'async_hooks' {
* @param type The type of async event.
* @param triggerAsyncId The ID of the execution context that created
* this async event (default: `executionAsyncId()`), or an
* AsyncResourceOptions object (since 9.3)
* AsyncResourceOptions object (since v9.3.0)
*/
constructor(type: string, triggerAsyncId?: number|AsyncResourceOptions);
constructor(type: string, triggerAsyncId?: number | AsyncResourceOptions);
/**
* Binds the given function to the current execution context.
*
* The returned function will have an `asyncResource` property referencing
* the `AsyncResource` to which the function is bound.
* @since v14.8.0, v12.19.0
* @param fn The function to bind to the current execution context.
* @param type An optional name to associate with the underlying `AsyncResource`.
*/
static bind<Func extends (...args: any[]) => any>(fn: Func, type?: string): Func & { asyncResource: AsyncResource };
static bind<Func extends (this: ThisArg, ...args: any[]) => any, ThisArg>(
fn: Func,
type?: string,
thisArg?: ThisArg
): Func & {
asyncResource: AsyncResource;
};
/**
* Binds the given function to execute to this `AsyncResource`'s scope.
*
* The returned function will have an `asyncResource` property referencing
* the `AsyncResource` to which the function is bound.
* @since v14.8.0, v12.19.0
* @param fn The function to bind to the current `AsyncResource`.
*/
bind<Func extends (...args: any[]) => any>(fn: Func): Func & { asyncResource: AsyncResource };
bind<Func extends (...args: any[]) => any>(
fn: Func
): Func & {
asyncResource: AsyncResource;
};
/**
* Call the provided function with the provided arguments in the
* execution context of the async resource. This will establish the
* context, trigger the AsyncHooks before callbacks, call the function,
* trigger the AsyncHooks after callbacks, and then restore the original
* execution context.
* @param fn The function to call in the execution context of this
* async resource.
* Call the provided function with the provided arguments in the execution context
* of the async resource. This will establish the context, trigger the AsyncHooks
* before callbacks, call the function, trigger the AsyncHooks after callbacks, and
* then restore the original execution context.
* @since v9.6.0
* @param fn The function to call in the execution context of this async resource.
* @param thisArg The receiver to be used for the function call.
* @param args Optional arguments to pass to the function.
*/
runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
/**
* Call AsyncHooks destroy callbacks.
* Call all `destroy` hooks. This should only ever be called once. An error will
* be thrown if it is called more than once. This **must** be manually called. If
* the resource is left to be collected by the GC then the `destroy` hooks will
* never be called.
* @return A reference to `asyncResource`.
*/
emitDestroy(): this;
/**
* @return the unique ID assigned to this AsyncResource instance.
* @return The unique `asyncId` assigned to the resource.
*/
asyncId(): number;
/**
* @return the trigger ID for this AsyncResource instance.
*
* @return The same `triggerAsyncId` that is passed to the `AsyncResource` constructor.
*/
triggerAsyncId(): number;
}
/**
* When having multiple instances of `AsyncLocalStorage`, they are independent
* from each other. It is safe to instantiate this class multiple times.
* This class creates stores that stay coherent through asynchronous operations.
*
* While you can create your own implementation on top of the `async_hooks` module,`AsyncLocalStorage` should be preferred as it is a performant and memory safe
* implementation that involves significant optimizations that are non-obvious to
* implement.
*
* The following example uses `AsyncLocalStorage` to build a simple logger
* that assigns IDs to incoming HTTP requests and includes them in messages
* logged within each request.
*
* ```js
* import http from 'http';
* import { AsyncLocalStorage } from 'async_hooks';
*
* const asyncLocalStorage = new AsyncLocalStorage();
*
* function logWithId(msg) {
* const id = asyncLocalStorage.getStore();
* console.log(`${id !== undefined ? id : '-'}:`, msg);
* }
*
* let idSeq = 0;
* http.createServer((req, res) => {
* asyncLocalStorage.run(idSeq++, () => {
* logWithId('start');
* // Imagine any chain of async operations here
* setImmediate(() => {
* logWithId('finish');
* res.end();
* });
* });
* }).listen(8080);
*
* http.get('http://localhost:8080');
* http.get('http://localhost:8080');
* // Prints:
* // 0: start
* // 1: start
* // 0: finish
* // 1: finish
* ```
*
* Each instance of `AsyncLocalStorage` maintains an independent storage context.
* Multiple instances can safely exist simultaneously without risk of interfering
* with each other data.
* @since v13.10.0, v12.17.0
*/
class AsyncLocalStorage<T> {
/**
* This method disables the instance of `AsyncLocalStorage`. All subsequent calls
* to `asyncLocalStorage.getStore()` will return `undefined` until
* `asyncLocalStorage.run()` is called again.
* Disables the instance of `AsyncLocalStorage`. All subsequent calls
* to `asyncLocalStorage.getStore()` will return `undefined` until`asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
*
* When calling `asyncLocalStorage.disable()`, all current contexts linked to the
* instance will be exited.
*
* Calling `asyncLocalStorage.disable()` is required before the
* `asyncLocalStorage` can be garbage collected. This does not apply to stores
* Calling `asyncLocalStorage.disable()` is required before the`asyncLocalStorage` can be garbage collected. This does not apply to stores
* provided by the `asyncLocalStorage`, as those objects are garbage collected
* along with the corresponding async resources.
*
* This method is to be used when the `asyncLocalStorage` is not in use anymore
* Use this method when the `asyncLocalStorage` is not in use anymore
* in the current process.
* @since v13.10.0, v12.17.0
* @experimental
*/
disable(): void;
/**
* This method returns the current store. If this method is called outside of an
* asynchronous context initialized by calling `asyncLocalStorage.run`, it will
* return `undefined`.
* Returns the current store.
* If called outside of an asynchronous context initialized by
* calling `asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()`, it
* returns `undefined`.
* @since v13.10.0, v12.17.0
*/
getStore(): T | undefined;
/**
* This methods runs a function synchronously within a context and return its
* Runs a function synchronously within a context and returns its
* return value. The store is not accessible outside of the callback function or
* the asynchronous operations created within the callback.
*
* Optionally, arguments can be passed to the function. They will be passed to the
* callback function.
* The optional `args` are passed to the callback function.
*
* I the callback function throws an error, it will be thrown by `run` too. The
* stacktrace will not be impacted by this call and the context will be exited.
* If the callback function throws an error, the error is thrown by `run()` too.
* The stacktrace is not impacted by this call and the context is exited.
*
* Example:
*
* ```js
* const store = { id: 2 };
* try {
* asyncLocalStorage.run(store, () => {
* asyncLocalStorage.getStore(); // Returns the store object
* throw new Error();
* });
* } catch (e) {
* asyncLocalStorage.getStore(); // Returns undefined
* // The error will be caught here
* }
* ```
* @since v13.10.0, v12.17.0
*/
// TODO: Apply generic vararg once available
run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
run<R, TArgs extends any[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
/**
* This methods runs a function synchronously outside of a context and return its
* return value. The store is not accessible within the callback function or the
* asynchronous operations created within the callback.
* Runs a function synchronously outside of a context and returns its
* return value. The store is not accessible within the callback function or
* the asynchronous operations created within the callback. Any `getStore()`call done within the callback function will always return `undefined`.
*
* Optionally, arguments can be passed to the function. They will be passed to the
* callback function.
* The optional `args` are passed to the callback function.
*
* If the callback function throws an error, it will be thrown by `exit` too. The
* stacktrace will not be impacted by this call and the context will be
* re-entered.
* If the callback function throws an error, the error is thrown by `exit()` too.
* The stacktrace is not impacted by this call and the context is re-entered.
*
* Example:
*
* ```js
* // Within a call to run
* try {
* asyncLocalStorage.getStore(); // Returns the store object or value
* asyncLocalStorage.exit(() => {
* asyncLocalStorage.getStore(); // Returns undefined
* throw new Error();
* });
* } catch (e) {
* asyncLocalStorage.getStore(); // Returns the same object or value
* // The error will be caught here
* }
* ```
* @since v13.10.0, v12.17.0
* @experimental
*/
// TODO: Apply generic vararg once available
exit<R>(callback: (...args: any[]) => R, ...args: any[]): R;
exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
/**
* Calling `asyncLocalStorage.enterWith(store)` will transition into the context
* for the remainder of the current synchronous execution and will persist
* through any following asynchronous calls.
* Transitions into the context for the remainder of the current
* synchronous execution and then persists the store through any following
* asynchronous calls.
*
* Example:
*
* ```js
* const store = { id: 1 };
* // Replaces previous store with the given store object
* asyncLocalStorage.enterWith(store);
* asyncLocalStorage.getStore(); // Returns the store object
* someAsyncOperation(() => {
* asyncLocalStorage.getStore(); // Returns the same object
* });
* ```
*
* This transition will continue for the _entire_ synchronous execution.
* This means that if, for example, the context is entered within an event
* handler subsequent event handlers will also run within that context unless
* specifically bound to another context with an `AsyncResource`. That is why`run()` should be preferred over `enterWith()` unless there are strong reasons
* to use the latter method.
*
* ```js
* const store = { id: 1 };
*
* emitter.on('my-event', () => {
* asyncLocalStorage.enterWith(store);
* });
* emitter.on('my-event', () => {
* asyncLocalStorage.getStore(); // Returns the same object
* });
*
* asyncLocalStorage.getStore(); // Returns undefined
* emitter.emit('my-event');
* asyncLocalStorage.getStore(); // Returns the same object
* ```
* @since v13.11.0, v12.17.0
* @experimental
*/
enterWith(store: T): void;
}

2172
packages/node_modules/@node-red/editor-client/src/types/node/buffer.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

1364
packages/node_modules/@node-red/editor-client/src/types/node/child_process.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

551
packages/node_modules/@node-red/editor-client/src/types/node/cluster.d.ts vendored
View File

@ -1,13 +1,64 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* A single instance of Node.js runs in a single thread. To take advantage of
* multi-core systems, the user will sometimes want to launch a cluster of Node.js
* processes to handle the load.
*
* The cluster module allows easy creation of child processes that all share
* server ports.
*
* ```js
* import cluster from 'cluster';
* import http from 'http';
* import { cpus } from 'os';
* import process from 'process';
*
* const numCPUs = cpus().length;
*
* if (cluster.isPrimary) {
* console.log(`Primary ${process.pid} is running`);
*
* // Fork workers.
* for (let i = 0; i < numCPUs; i++) {
* cluster.fork();
* }
*
* cluster.on('exit', (worker, code, signal) => {
* console.log(`worker ${worker.process.pid} died`);
* });
* } else {
* // Workers can share any TCP connection
* // In this case it is an HTTP server
* http.createServer((req, res) => {
* res.writeHead(200);
* res.end('hello world\n');
* }).listen(8000);
*
* console.log(`Worker ${process.pid} started`);
* }
* ```
*
* Running Node.js will now share port 8000 between the workers:
*
* ```console
* $ node server.js
* Primary 3596 is running
* Worker 4324 started
* Worker 4520 started
* Worker 6056 started
* Worker 5644 started
* ```
*
* On Windows, it is not yet possible to set up a named pipe server in a worker.
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/cluster.js)
*/
declare module 'cluster' {
import * as child from 'child_process';
import EventEmitter = require('events');
import * as net from 'net';
// interfaces
interface ClusterSettings {
import * as child from 'node:child_process';
import EventEmitter = require('node:events');
import * as net from 'node:net';
export interface ClusterSettings {
execArgv?: string[] | undefined; // default: process.execArgv
exec?: string | undefined;
args?: string[] | undefined;
@ -17,24 +68,214 @@ declare module 'cluster' {
gid?: number | undefined;
inspectPort?: number | (() => number) | undefined;
}
interface Address {
export interface Address {
address: string;
port: number;
addressType: number | "udp4" | "udp6"; // 4, 6, -1, "udp4", "udp6"
addressType: number | 'udp4' | 'udp6'; // 4, 6, -1, "udp4", "udp6"
}
class Worker extends EventEmitter {
/**
* A `Worker` object contains all public information and method about a worker.
* In the primary it can be obtained using `cluster.workers`. In a worker
* it can be obtained using `cluster.worker`.
* @since v0.7.0
*/
export class Worker extends EventEmitter {
/**
* Each new worker is given its own unique id, this id is stored in the`id`.
*
* While a worker is alive, this is the key that indexes it in`cluster.workers`.
* @since v0.8.0
*/
id: number;
/**
* All workers are created using `child_process.fork()`, the returned object
* from this function is stored as `.process`. In a worker, the global `process`is stored.
*
* See: `Child Process module`.
*
* Workers will call `process.exit(0)` if the `'disconnect'` event occurs
* on `process` and `.exitedAfterDisconnect` is not `true`. This protects against
* accidental disconnection.
* @since v0.7.0
*/
process: child.ChildProcess;
send(message: child.Serializable, sendHandle?: child.SendHandle, callback?: (error: Error | null) => void): boolean;
/**
* Send a message to a worker or primary, optionally with a handle.
*
* In the primary this sends a message to a specific worker. It is identical to `ChildProcess.send()`.
*
* In a worker this sends a message to the primary. It is identical to`process.send()`.
*
* This example will echo back all messages from the primary:
*
* ```js
* if (cluster.isPrimary) {
* const worker = cluster.fork();
* worker.send('hi there');
*
* } else if (cluster.isWorker) {
* process.on('message', (msg) => {
* process.send(msg);
* });
* }
* ```
* @since v0.7.0
* @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. `options` supports the following properties:
*/
send(message: child.Serializable, callback?: (error: Error | null) => void): boolean;
send(message: child.Serializable, sendHandle: child.SendHandle, callback?: (error: Error | null) => void): boolean;
send(message: child.Serializable, sendHandle: child.SendHandle, options?: child.MessageOptions, callback?: (error: Error | null) => void): boolean;
/**
* This function will kill the worker. In the primary, it does this
* by disconnecting the `worker.process`, and once disconnected, killing
* with `signal`. In the worker, it does it by disconnecting the channel,
* and then exiting with code `0`.
*
* Because `kill()` attempts to gracefully disconnect the worker process, it is
* susceptible to waiting indefinitely for the disconnect to complete. For example,
* if the worker enters an infinite loop, a graceful disconnect will never occur.
* If the graceful disconnect behavior is not needed, use `worker.process.kill()`.
*
* Causes `.exitedAfterDisconnect` to be set.
*
* This method is aliased as `worker.destroy()` for backward compatibility.
*
* In a worker, `process.kill()` exists, but it is not this function;
* it is `kill()`.
* @since v0.9.12
* @param [signal='SIGTERM'] Name of the kill signal to send to the worker process.
*/
kill(signal?: string): void;
destroy(signal?: string): void;
/**
* In a worker, this function will close all servers, wait for the `'close'` event
* on those servers, and then disconnect the IPC channel.
*
* In the primary, an internal message is sent to the worker causing it to call`.disconnect()` on itself.
*
* Causes `.exitedAfterDisconnect` to be set.
*
* After a server is closed, it will no longer accept new connections,
* but connections may be accepted by any other listening worker. Existing
* connections will be allowed to close as usual. When no more connections exist,
* see `server.close()`, the IPC channel to the worker will close allowing it
* to die gracefully.
*
* The above applies _only_ to server connections, client connections are not
* automatically closed by workers, and disconnect does not wait for them to close
* before exiting.
*
* In a worker, `process.disconnect` exists, but it is not this function;
* it is `disconnect()`.
*
* Because long living server connections may block workers from disconnecting, it
* may be useful to send a message, so application specific actions may be taken to
* close them. It also may be useful to implement a timeout, killing a worker if
* the `'disconnect'` event has not been emitted after some time.
*
* ```js
* if (cluster.isPrimary) {
* const worker = cluster.fork();
* let timeout;
*
* worker.on('listening', (address) => {
* worker.send('shutdown');
* worker.disconnect();
* timeout = setTimeout(() => {
* worker.kill();
* }, 2000);
* });
*
* worker.on('disconnect', () => {
* clearTimeout(timeout);
* });
*
* } else if (cluster.isWorker) {
* const net = require('net');
* const server = net.createServer((socket) => {
* // Connections never end
* });
*
* server.listen(8000);
*
* process.on('message', (msg) => {
* if (msg === 'shutdown') {
* // Initiate graceful close of any connections to server
* }
* });
* }
* ```
* @since v0.7.7
* @return A reference to `worker`.
*/
disconnect(): void;
/**
* This function returns `true` if the worker is connected to its primary via its
* IPC channel, `false` otherwise. A worker is connected to its primary after it
* has been created. It is disconnected after the `'disconnect'` event is emitted.
* @since v0.11.14
*/
isConnected(): boolean;
/**
* This function returns `true` if the worker's process has terminated (either
* because of exiting or being signaled). Otherwise, it returns `false`.
*
* ```js
* import cluster from 'cluster';
* import http from 'http';
* import { cpus } from 'os';
* import process from 'process';
*
* const numCPUs = cpus().length;
*
* if (cluster.isPrimary) {
* console.log(`Primary ${process.pid} is running`);
*
* // Fork workers.
* for (let i = 0; i < numCPUs; i++) {
* cluster.fork();
* }
*
* cluster.on('fork', (worker) => {
* console.log('worker is dead:', worker.isDead());
* });
*
* cluster.on('exit', (worker, code, signal) => {
* console.log('worker is dead:', worker.isDead());
* });
* } else {
* // Workers can share any TCP connection. In this case, it is an HTTP server.
* http.createServer((req, res) => {
* res.writeHead(200);
* res.end(`Current process\n ${process.pid}`);
* process.kill(process.pid);
* }).listen(8000);
* }
* ```
* @since v0.11.14
*/
isDead(): boolean;
/**
* This property is `true` if the worker exited due to `.kill()` or`.disconnect()`. If the worker exited any other way, it is `false`. If the
* worker has not exited, it is `undefined`.
*
* The boolean `worker.exitedAfterDisconnect` allows distinguishing between
* voluntary and accidental exit, the primary may choose not to respawn a worker
* based on this value.
*
* ```js
* cluster.on('exit', (worker, code, signal) => {
* if (worker.exitedAfterDisconnect === true) {
* console.log('Oh, it was just voluntary – no need to worry');
* }
* });
*
* // kill worker
* worker.kill();
* ```
* @since v6.0.0
*/
exitedAfterDisconnect: boolean;
/**
* events.EventEmitter
* 1. disconnect
@ -45,69 +286,67 @@ declare module 'cluster' {
* 6. online
*/
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "disconnect", listener: () => void): this;
addListener(event: "error", listener: (error: Error) => void): this;
addListener(event: "exit", listener: (code: number, signal: string) => void): this;
addListener(event: "listening", listener: (address: Address) => void): this;
addListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
addListener(event: "online", listener: () => void): this;
addListener(event: 'disconnect', listener: () => void): this;
addListener(event: 'error', listener: (error: Error) => void): this;
addListener(event: 'exit', listener: (code: number, signal: string) => void): this;
addListener(event: 'listening', listener: (address: Address) => void): this;
addListener(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
addListener(event: 'online', listener: () => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "disconnect"): boolean;
emit(event: "error", error: Error): boolean;
emit(event: "exit", code: number, signal: string): boolean;
emit(event: "listening", address: Address): boolean;
emit(event: "message", message: any, handle: net.Socket | net.Server): boolean;
emit(event: "online"): boolean;
emit(event: 'disconnect'): boolean;
emit(event: 'error', error: Error): boolean;
emit(event: 'exit', code: number, signal: string): boolean;
emit(event: 'listening', address: Address): boolean;
emit(event: 'message', message: any, handle: net.Socket | net.Server): boolean;
emit(event: 'online'): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "disconnect", listener: () => void): this;
on(event: "error", listener: (error: Error) => void): this;
on(event: "exit", listener: (code: number, signal: string) => void): this;
on(event: "listening", listener: (address: Address) => void): this;
on(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
on(event: "online", listener: () => void): this;
on(event: 'disconnect', listener: () => void): this;
on(event: 'error', listener: (error: Error) => void): this;
on(event: 'exit', listener: (code: number, signal: string) => void): this;
on(event: 'listening', listener: (address: Address) => void): this;
on(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
on(event: 'online', listener: () => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "disconnect", listener: () => void): this;
once(event: "error", listener: (error: Error) => void): this;
once(event: "exit", listener: (code: number, signal: string) => void): this;
once(event: "listening", listener: (address: Address) => void): this;
once(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
once(event: "online", listener: () => void): this;
once(event: 'disconnect', listener: () => void): this;
once(event: 'error', listener: (error: Error) => void): this;
once(event: 'exit', listener: (code: number, signal: string) => void): this;
once(event: 'listening', listener: (address: Address) => void): this;
once(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
once(event: 'online', listener: () => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "disconnect", listener: () => void): this;
prependListener(event: "error", listener: (error: Error) => void): this;
prependListener(event: "exit", listener: (code: number, signal: string) => void): this;
prependListener(event: "listening", listener: (address: Address) => void): this;
prependListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
prependListener(event: "online", listener: () => void): this;
prependListener(event: 'disconnect', listener: () => void): this;
prependListener(event: 'error', listener: (error: Error) => void): this;
prependListener(event: 'exit', listener: (code: number, signal: string) => void): this;
prependListener(event: 'listening', listener: (address: Address) => void): this;
prependListener(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
prependListener(event: 'online', listener: () => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "disconnect", listener: () => void): this;
prependOnceListener(event: "error", listener: (error: Error) => void): this;
prependOnceListener(event: "exit", listener: (code: number, signal: string) => void): this;
prependOnceListener(event: "listening", listener: (address: Address) => void): this;
prependOnceListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
prependOnceListener(event: "online", listener: () => void): this;
prependOnceListener(event: 'disconnect', listener: () => void): this;
prependOnceListener(event: 'error', listener: (error: Error) => void): this;
prependOnceListener(event: 'exit', listener: (code: number, signal: string) => void): this;
prependOnceListener(event: 'listening', listener: (address: Address) => void): this;
prependOnceListener(event: 'message', listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
prependOnceListener(event: 'online', listener: () => void): this;
}
interface Cluster extends EventEmitter {
Worker: Worker;
export interface Cluster extends EventEmitter {
disconnect(callback?: () => void): void;
fork(env?: any): Worker;
isMaster: boolean;
isWorker: boolean;
/** @deprecated since v16.0.0 - use isPrimary. */
readonly isMaster: boolean;
readonly isPrimary: boolean;
readonly isWorker: boolean;
schedulingPolicy: number;
settings: ClusterSettings;
readonly settings: ClusterSettings;
/** @deprecated since v16.0.0 - use setupPrimary. */
setupMaster(settings?: ClusterSettings): void;
worker?: Worker | undefined;
workers?: NodeJS.Dict<Worker> | undefined;
/**
* `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in cluster.settings.
*/
setupPrimary(settings?: ClusterSettings): void;
readonly worker?: Worker | undefined;
readonly workers?: NodeJS.Dict<Worker> | undefined;
readonly SCHED_NONE: number;
readonly SCHED_RR: number;
/**
* events.EventEmitter
* 1. disconnect
@ -119,150 +358,60 @@ declare module 'cluster' {
* 7. setup
*/
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "disconnect", listener: (worker: Worker) => void): this;
addListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
addListener(event: "fork", listener: (worker: Worker) => void): this;
addListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;
addListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
addListener(event: "online", listener: (worker: Worker) => void): this;
addListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
addListener(event: 'disconnect', listener: (worker: Worker) => void): this;
addListener(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
addListener(event: 'fork', listener: (worker: Worker) => void): this;
addListener(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
addListener(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
addListener(event: 'online', listener: (worker: Worker) => void): this;
addListener(event: 'setup', listener: (settings: ClusterSettings) => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "disconnect", worker: Worker): boolean;
emit(event: "exit", worker: Worker, code: number, signal: string): boolean;
emit(event: "fork", worker: Worker): boolean;
emit(event: "listening", worker: Worker, address: Address): boolean;
emit(event: "message", worker: Worker, message: any, handle: net.Socket | net.Server): boolean;
emit(event: "online", worker: Worker): boolean;
emit(event: "setup", settings: ClusterSettings): boolean;
emit(event: 'disconnect', worker: Worker): boolean;
emit(event: 'exit', worker: Worker, code: number, signal: string): boolean;
emit(event: 'fork', worker: Worker): boolean;
emit(event: 'listening', worker: Worker, address: Address): boolean;
emit(event: 'message', worker: Worker, message: any, handle: net.Socket | net.Server): boolean;
emit(event: 'online', worker: Worker): boolean;
emit(event: 'setup', settings: ClusterSettings): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "disconnect", listener: (worker: Worker) => void): this;
on(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
on(event: "fork", listener: (worker: Worker) => void): this;
on(event: "listening", listener: (worker: Worker, address: Address) => void): this;
on(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
on(event: "online", listener: (worker: Worker) => void): this;
on(event: "setup", listener: (settings: ClusterSettings) => void): this;
on(event: 'disconnect', listener: (worker: Worker) => void): this;
on(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
on(event: 'fork', listener: (worker: Worker) => void): this;
on(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
on(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
on(event: 'online', listener: (worker: Worker) => void): this;
on(event: 'setup', listener: (settings: ClusterSettings) => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "disconnect", listener: (worker: Worker) => void): this;
once(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
once(event: "fork", listener: (worker: Worker) => void): this;
once(event: "listening", listener: (worker: Worker, address: Address) => void): this;
once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
once(event: "online", listener: (worker: Worker) => void): this;
once(event: "setup", listener: (settings: ClusterSettings) => void): this;
once(event: 'disconnect', listener: (worker: Worker) => void): this;
once(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
once(event: 'fork', listener: (worker: Worker) => void): this;
once(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
once(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
once(event: 'online', listener: (worker: Worker) => void): this;
once(event: 'setup', listener: (settings: ClusterSettings) => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "disconnect", listener: (worker: Worker) => void): this;
prependListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
prependListener(event: "fork", listener: (worker: Worker) => void): this;
prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;
prependListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
prependListener(event: "online", listener: (worker: Worker) => void): this;
prependListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "disconnect", listener: (worker: Worker) => void): this;
prependOnceListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
prependOnceListener(event: "fork", listener: (worker: Worker) => void): this;
prependOnceListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;
prependListener(event: 'disconnect', listener: (worker: Worker) => void): this;
prependListener(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
prependListener(event: 'fork', listener: (worker: Worker) => void): this;
prependListener(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
// the handle is a net.Socket or net.Server object, or undefined.
prependOnceListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;
prependOnceListener(event: "online", listener: (worker: Worker) => void): this;
prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
prependListener(event: 'message', listener: (worker: Worker, message: any, handle?: net.Socket | net.Server) => void): this;
prependListener(event: 'online', listener: (worker: Worker) => void): this;
prependListener(event: 'setup', listener: (settings: ClusterSettings) => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: 'disconnect', listener: (worker: Worker) => void): this;
prependOnceListener(event: 'exit', listener: (worker: Worker, code: number, signal: string) => void): this;
prependOnceListener(event: 'fork', listener: (worker: Worker) => void): this;
prependOnceListener(event: 'listening', listener: (worker: Worker, address: Address) => void): this;
// the handle is a net.Socket or net.Server object, or undefined.
prependOnceListener(event: 'message', listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;
prependOnceListener(event: 'online', listener: (worker: Worker) => void): this;
prependOnceListener(event: 'setup', listener: (settings: ClusterSettings) => void): this;
}
const SCHED_NONE: number;
const SCHED_RR: number;
function disconnect(callback?: () => void): void;
function fork(env?: any): Worker;
const isMaster: boolean;
const isWorker: boolean;
let schedulingPolicy: number;
const settings: ClusterSettings;
function setupMaster(settings?: ClusterSettings): void;
const worker: Worker;
const workers: NodeJS.Dict<Worker>;
/**
* events.EventEmitter
* 1. disconnect
* 2. exit
* 3. fork
* 4. listening
* 5. message
* 6. online
* 7. setup
*/
function addListener(event: string, listener: (...args: any[]) => void): Cluster;
function addListener(event: "disconnect", listener: (worker: Worker) => void): Cluster;
function addListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
function addListener(event: "fork", listener: (worker: Worker) => void): Cluster;
function addListener(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
// the handle is a net.Socket or net.Server object, or undefined.
function addListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
function addListener(event: "online", listener: (worker: Worker) => void): Cluster;
function addListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
function emit(event: string | symbol, ...args: any[]): boolean;
function emit(event: "disconnect", worker: Worker): boolean;
function emit(event: "exit", worker: Worker, code: number, signal: string): boolean;
function emit(event: "fork", worker: Worker): boolean;
function emit(event: "listening", worker: Worker, address: Address): boolean;
function emit(event: "message", worker: Worker, message: any, handle: net.Socket | net.Server): boolean;
function emit(event: "online", worker: Worker): boolean;
function emit(event: "setup", settings: ClusterSettings): boolean;
function on(event: string, listener: (...args: any[]) => void): Cluster;
function on(event: "disconnect", listener: (worker: Worker) => void): Cluster;
function on(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
function on(event: "fork", listener: (worker: Worker) => void): Cluster;
function on(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
function on(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster; // the handle is a net.Socket or net.Server object, or undefined.
function on(event: "online", listener: (worker: Worker) => void): Cluster;
function on(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
function once(event: string, listener: (...args: any[]) => void): Cluster;
function once(event: "disconnect", listener: (worker: Worker) => void): Cluster;
function once(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
function once(event: "fork", listener: (worker: Worker) => void): Cluster;
function once(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
function once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster; // the handle is a net.Socket or net.Server object, or undefined.
function once(event: "online", listener: (worker: Worker) => void): Cluster;
function once(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
function removeListener(event: string, listener: (...args: any[]) => void): Cluster;
function removeAllListeners(event?: string): Cluster;
function setMaxListeners(n: number): Cluster;
function getMaxListeners(): number;
function listeners(event: string): Function[];
function listenerCount(type: string): number;
function prependListener(event: string, listener: (...args: any[]) => void): Cluster;
function prependListener(event: "disconnect", listener: (worker: Worker) => void): Cluster;
function prependListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
function prependListener(event: "fork", listener: (worker: Worker) => void): Cluster;
function prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
// the handle is a net.Socket or net.Server object, or undefined.
function prependListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
function prependListener(event: "online", listener: (worker: Worker) => void): Cluster;
function prependListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
function prependOnceListener(event: string, listener: (...args: any[]) => void): Cluster;
function prependOnceListener(event: "disconnect", listener: (worker: Worker) => void): Cluster;
function prependOnceListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
function prependOnceListener(event: "fork", listener: (worker: Worker) => void): Cluster;
function prependOnceListener(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
// the handle is a net.Socket or net.Server object, or undefined.
function prependOnceListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
function prependOnceListener(event: "online", listener: (worker: Worker) => void): Cluster;
function prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
function eventNames(): string[];
const cluster: Cluster;
export default cluster;
}
declare module 'node:cluster' {
export * from 'cluster';
export { default as default } from 'cluster';
}

356
packages/node_modules/@node-red/editor-client/src/types/node/console.d.ts vendored
View File

@ -1,100 +1,321 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `console` module provides a simple debugging console that is similar to the
* JavaScript console mechanism provided by web browsers.
*
* The module exports two specific components:
*
* * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
* * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
*
* _**Warning**_: The global console object's methods are neither consistently
* synchronous like the browser APIs they resemble, nor are they consistently
* asynchronous like all other Node.js streams. See the `note on process I/O` for
* more information.
*
* Example using the global `console`:
*
* ```js
* console.log('hello world');
* // Prints: hello world, to stdout
* console.log('hello %s', 'world');
* // Prints: hello world, to stdout
* console.error(new Error('Whoops, something bad happened'));
* // Prints error message and stack trace to stderr:
* // Error: Whoops, something bad happened
* // at [eval]:5:15
* // at Script.runInThisContext (node:vm:132:18)
* // at Object.runInThisContext (node:vm:309:38)
* // at node:internal/process/execution:77:19
* // at [eval]-wrapper:6:22
* // at evalScript (node:internal/process/execution:76:60)
* // at node:internal/main/eval_string:23:3
*
* const name = 'Will Robinson';
* console.warn(`Danger ${name}! Danger!`);
* // Prints: Danger Will Robinson! Danger!, to stderr
* ```
*
* Example using the `Console` class:
*
* ```js
* const out = getStreamSomehow();
* const err = getStreamSomehow();
* const myConsole = new console.Console(out, err);
*
* myConsole.log('hello world');
* // Prints: hello world, to out
* myConsole.log('hello %s', 'world');
* // Prints: hello world, to out
* myConsole.error(new Error('Whoops, something bad happened'));
* // Prints: [Error: Whoops, something bad happened], to err
*
* const name = 'Will Robinson';
* myConsole.warn(`Danger ${name}! Danger!`);
* // Prints: Danger Will Robinson! Danger!, to err
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/console.js)
*/
declare module 'console' {
import console = require('node:console');
export = console;
}
declare module 'node:console' {
import { InspectOptions } from 'util';
import { InspectOptions } from 'node:util';
global {
// This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build
interface Console {
Console: NodeJS.ConsoleConstructor;
Console: console.ConsoleConstructor;
/**
* A simple assertion test that verifies whether `value` is truthy.
* If it is not, an `AssertionError` is thrown.
* If provided, the error `message` is formatted using `util.format()` and used as the error message.
* `console.assert()` writes a message if `value` is [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) or omitted. It only
* writes a message and does not otherwise affect execution. The output always
* starts with `"Assertion failed"`. If provided, `message` is formatted using `util.format()`.
*
* If `value` is [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy), nothing happens.
*
* ```js
* console.assert(true, 'does nothing');
*
* console.assert(false, 'Whoops %s work', 'didn\'t');
* // Assertion failed: Whoops didn't work
*
* console.assert();
* // Assertion failed
* ```
* @since v0.1.101
* @param value The value tested for being truthy.
* @param message All arguments besides `value` are used as error message.
*/
assert(value: any, message?: string, ...optionalParams: any[]): void;
/**
* When `stdout` is a TTY, calling `console.clear()` will attempt to clear the TTY.
* When `stdout` is not a TTY, this method does nothing.
* When `stdout` is a TTY, calling `console.clear()` will attempt to clear the
* TTY. When `stdout` is not a TTY, this method does nothing.
*
* The specific operation of `console.clear()` can vary across operating systems
* and terminal types. For most Linux operating systems, `console.clear()`operates similarly to the `clear` shell command. On Windows, `console.clear()`will clear only the output in the
* current terminal viewport for the Node.js
* binary.
* @since v8.3.0
*/
clear(): void;
/**
* Maintains an internal counter specific to `label` and outputs to `stdout` the number of times `console.count()` has been called with the given `label`.
* Maintains an internal counter specific to `label` and outputs to `stdout` the
* number of times `console.count()` has been called with the given `label`.
*
* ```js
* > console.count()
* default: 1
* undefined
* > console.count('default')
* default: 2
* undefined
* > console.count('abc')
* abc: 1
* undefined
* > console.count('xyz')
* xyz: 1
* undefined
* > console.count('abc')
* abc: 2
* undefined
* > console.count()
* default: 3
* undefined
* >
* ```
* @since v8.3.0
* @param label The display label for the counter.
*/
count(label?: string): void;
/**
* Resets the internal counter specific to `label`.
*
* ```js
* > console.count('abc');
* abc: 1
* undefined
* > console.countReset('abc');
* undefined
* > console.count('abc');
* abc: 1
* undefined
* >
* ```
* @since v8.3.0
* @param label The display label for the counter.
*/
countReset(label?: string): void;
/**
* The `console.debug()` function is an alias for {@link console.log}.
* The `console.debug()` function is an alias for {@link log}.
* @since v8.0.0
*/
debug(message?: any, ...optionalParams: any[]): void;
/**
* Uses {@link util.inspect} on `obj` and prints the resulting string to `stdout`.
* Uses `util.inspect()` on `obj` and prints the resulting string to `stdout`.
* This function bypasses any custom `inspect()` function defined on `obj`.
* @since v0.1.101
*/
dir(obj: any, options?: InspectOptions): void;
/**
* This method calls {@link console.log} passing it the arguments received. Please note that this method does not produce any XML formatting
* This method calls `console.log()` passing it the arguments received.
* This method does not produce any XML formatting.
* @since v8.0.0
*/
dirxml(...data: any[]): void;
/**
* Prints to `stderr` with newline.
* Prints to `stderr` with newline. Multiple arguments can be passed, with the
* first used as the primary message and all additional used as substitution
* values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
*
* ```js
* const code = 5;
* console.error('error #%d', code);
* // Prints: error #5, to stderr
* console.error('error', code);
* // Prints: error 5, to stderr
* ```
*
* If formatting elements (e.g. `%d`) are not found in the first string then `util.inspect()` is called on each argument and the resulting string
* values are concatenated. See `util.format()` for more information.
* @since v0.1.100
*/
error(message?: any, ...optionalParams: any[]): void;
/**
* Increases indentation of subsequent lines by two spaces.
* If one or more `label`s are provided, those are printed first without the additional indentation.
* Increases indentation of subsequent lines by spaces for `groupIndentation`length.
*
* If one or more `label`s are provided, those are printed first without the
* additional indentation.
* @since v8.5.0
*/
group(...label: any[]): void;
/**
* The `console.groupCollapsed()` function is an alias for {@link console.group}.
* An alias for {@link group}.
* @since v8.5.0
*/
groupCollapsed(...label: any[]): void;
/**
* Decreases indentation of subsequent lines by two spaces.
* Decreases indentation of subsequent lines by spaces for `groupIndentation`length.
* @since v8.5.0
*/
groupEnd(): void;
/**
* The {@link console.info} function is an alias for {@link console.log}.
* The `console.info()` function is an alias for {@link log}.
* @since v0.1.100
*/
info(message?: any, ...optionalParams: any[]): void;
/**
* Prints to `stdout` with newline.
* Prints to `stdout` with newline. Multiple arguments can be passed, with the
* first used as the primary message and all additional used as substitution
* values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
*
* ```js
* const count = 5;
* console.log('count: %d', count);
* // Prints: count: 5, to stdout
* console.log('count:', count);
* // Prints: count: 5, to stdout
* ```
*
* See `util.format()` for more information.
* @since v0.1.100
*/
log(message?: any, ...optionalParams: any[]): void;
/**
* This method does not display anything unless used in the inspector.
* Prints to `stdout` the array `array` formatted as a table.
* Try to construct a table with the columns of the properties of `tabularData`(or use `properties`) and rows of `tabularData` and log it. Falls back to just
* logging the argument if it can’t be parsed as tabular.
*
* ```js
* // These can't be parsed as tabular data
* console.table(Symbol());
* // Symbol()
*
* console.table(undefined);
* // undefined
*
* console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }]);
* // ┌─────────┬─────┬─────┐
* // │ (index) │ a │ b │
* // ├─────────┼─────┼─────┤
* // │ 0 │ 1 │ 'Y' │
* // │ 1 │ 'Z' │ 2 │
* // └─────────┴─────┴─────┘
*
* console.table([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], ['a']);
* // ┌─────────┬─────┐
* // │ (index) │ a │
* // ├─────────┼─────┤
* // │ 0 │ 1 │
* // │ 1 │ 'Z' │
* // └─────────┴─────┘
* ```
* @since v10.0.0
* @param properties Alternate properties for constructing the table.
*/
table(tabularData: any, properties?: ReadonlyArray<string>): void;
/**
* Starts a timer that can be used to compute the duration of an operation. Timers are identified by a unique `label`.
* Starts a timer that can be used to compute the duration of an operation. Timers
* are identified by a unique `label`. Use the same `label` when calling {@link timeEnd} to stop the timer and output the elapsed time in
* suitable time units to `stdout`. For example, if the elapsed
* time is 3869ms, `console.timeEnd()` displays "3.869s".
* @since v0.1.104
*/
time(label?: string): void;
/**
* Stops a timer that was previously started by calling {@link console.time} and prints the result to `stdout`.
* Stops a timer that was previously started by calling {@link time} and
* prints the result to `stdout`:
*
* ```js
* console.time('100-elements');
* for (let i = 0; i < 100; i++) {}
* console.timeEnd('100-elements');
* // prints 100-elements: 225.438ms
* ```
* @since v0.1.104
*/
timeEnd(label?: string): void;
/**
* For a timer that was previously started by calling {@link console.time}, prints the elapsed time and other `data` arguments to `stdout`.
* For a timer that was previously started by calling {@link time}, prints
* the elapsed time and other `data` arguments to `stdout`:
*
* ```js
* console.time('process');
* const value = expensiveProcess1(); // Returns 42
* console.timeLog('process', value);
* // Prints "process: 365.227ms 42".
* doExpensiveProcess2(value);
* console.timeEnd('process');
* ```
* @since v10.7.0
*/
timeLog(label?: string, ...data: any[]): void;
/**
* Prints to `stderr` the string 'Trace :', followed by the {@link util.format} formatted message and stack trace to the current position in the code.
* Prints to `stderr` the string `'Trace: '`, followed by the `util.format()` formatted message and stack trace to the current position in the code.
*
* ```js
* console.trace('Show me');
* // Prints: (stack trace will vary based on where trace is called)
* // Trace: Show me
* // at repl:2:9
* // at REPLServer.defaultEval (repl.js:248:27)
* // at bound (domain.js:287:14)
* // at REPLServer.runBound [as eval] (domain.js:300:12)
* // at REPLServer.<anonymous> (repl.js:412:12)
* // at emitOne (events.js:82:20)
* // at REPLServer.emit (events.js:169:7)
* // at REPLServer.Interface._onLine (readline.js:210:10)
* // at REPLServer.Interface._line (readline.js:549:8)
* // at REPLServer.Interface._ttyWrite (readline.js:826:14)
* ```
* @since v0.1.104
*/
trace(message?: any, ...optionalParams: any[]): void;
/**
* The {@link console.warn} function is an alias for {@link console.error}.
* The `console.warn()` function is an alias for {@link error}.
* @since v0.1.100
*/
warn(message?: any, ...optionalParams: any[]): void;
// --- Inspector mode only ---
/**
* This method does not display anything unless used in the inspector.
@ -112,13 +333,67 @@ declare module 'node:console' {
*/
timeStamp(label?: string): void;
}
var console: Console;
namespace NodeJS {
/**
* The `console` module provides a simple debugging console that is similar to the
* JavaScript console mechanism provided by web browsers.
*
* The module exports two specific components:
*
* * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
* * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
*
* _**Warning**_: The global console object's methods are neither consistently
* synchronous like the browser APIs they resemble, nor are they consistently
* asynchronous like all other Node.js streams. See the `note on process I/O` for
* more information.
*
* Example using the global `console`:
*
* ```js
* console.log('hello world');
* // Prints: hello world, to stdout
* console.log('hello %s', 'world');
* // Prints: hello world, to stdout
* console.error(new Error('Whoops, something bad happened'));
* // Prints error message and stack trace to stderr:
* // Error: Whoops, something bad happened
* // at [eval]:5:15
* // at Script.runInThisContext (node:vm:132:18)
* // at Object.runInThisContext (node:vm:309:38)
* // at node:internal/process/execution:77:19
* // at [eval]-wrapper:6:22
* // at evalScript (node:internal/process/execution:76:60)
* // at node:internal/main/eval_string:23:3
*
* const name = 'Will Robinson';
* console.warn(`Danger ${name}! Danger!`);
* // Prints: Danger Will Robinson! Danger!, to stderr
* ```
*
* Example using the `Console` class:
*
* ```js
* const out = getStreamSomehow();
* const err = getStreamSomehow();
* const myConsole = new console.Console(out, err);
*
* myConsole.log('hello world');
* // Prints: hello world, to out
* myConsole.log('hello %s', 'world');
* // Prints: hello world, to out
* myConsole.error(new Error('Whoops, something bad happened'));
* // Prints: [Error: Whoops, something bad happened], to err
*
* const name = 'Will Robinson';
* myConsole.warn(`Danger ${name}! Danger!`);
* // Prints: Danger Will Robinson! Danger!, to err
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/console.js)
*/
namespace console {
interface ConsoleConstructorOptions {
stdout: WritableStream;
stderr?: WritableStream | undefined;
stdout: NodeJS.WritableStream;
stderr?: NodeJS.WritableStream | undefined;
ignoreErrors?: boolean | undefined;
colorMode?: boolean | 'auto' | undefined;
inspectOptions?: InspectOptions | undefined;
@ -126,20 +401,15 @@ declare module 'node:console' {
* Set group indentation
* @default 2
*/
groupIndentation?: number | undefined;
groupIndentation?: number | undefined;
}
interface ConsoleConstructor {
prototype: Console;
new(stdout: WritableStream, stderr?: WritableStream, ignoreErrors?: boolean): Console;
new(options: ConsoleConstructorOptions): Console;
}
interface Global {
console: typeof console;
new (stdout: NodeJS.WritableStream, stderr?: NodeJS.WritableStream, ignoreErrors?: boolean): Console;
new (options: ConsoleConstructorOptions): Console;
}
}
var console: Console;
}
export = console;
export = globalThis.console;
}

3997
packages/node_modules/@node-red/editor-client/src/types/node/crypto.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

4
packages/node_modules/@node-red/editor-client/src/types/node/desktop.ini vendored Normal file
View File

@ -0,0 +1,4 @@
[ViewState]
Mode=
Vid=
FolderType=Generic

517
packages/node_modules/@node-red/editor-client/src/types/node/dgram.d.ts vendored
View File

@ -1,28 +1,51 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `dgram` module provides an implementation of UDP datagram sockets.
*
* ```js
* import dgram from 'dgram';
*
* const server = dgram.createSocket('udp4');
*
* server.on('error', (err) => {
* console.log(`server error:\n${err.stack}`);
* server.close();
* });
*
* server.on('message', (msg, rinfo) => {
* console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
* });
*
* server.on('listening', () => {
* const address = server.address();
* console.log(`server listening ${address.address}:${address.port}`);
* });
*
* server.bind(41234);
* // Prints: server listening 0.0.0.0:41234
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/dgram.js)
*/
declare module 'dgram' {
import { AddressInfo } from 'net';
import * as dns from 'dns';
import EventEmitter = require('events');
import { AddressInfo } from 'node:net';
import * as dns from 'node:dns';
import { EventEmitter, Abortable } from 'node:events';
interface RemoteInfo {
address: string;
family: 'IPv4' | 'IPv6';
port: number;
size: number;
}
interface BindOptions {
port?: number | undefined;
address?: string | undefined;
exclusive?: boolean | undefined;
fd?: number | undefined;
}
type SocketType = "udp4" | "udp6";
interface SocketOptions {
type SocketType = 'udp4' | 'udp6';
interface SocketOptions extends Abortable {
type: SocketType;
reuseAddr?: boolean | undefined;
/**
@ -33,64 +56,447 @@ declare module 'dgram' {
sendBufferSize?: number | undefined;
lookup?: ((hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void) | undefined;
}
/**
* Creates a `dgram.Socket` object. Once the socket is created, calling `socket.bind()` will instruct the socket to begin listening for datagram
* messages. When `address` and `port` are not passed to `socket.bind()` the
* method will bind the socket to the "all interfaces" address on a random port
* (it does the right thing for both `udp4` and `udp6` sockets). The bound address
* and port can be retrieved using `socket.address().address` and `socket.address().port`.
*
* If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.close()` on the socket:
*
* ```js
* const controller = new AbortController();
* const { signal } = controller;
* const server = dgram.createSocket({ type: 'udp4', signal });
* server.on('message', (msg, rinfo) => {
* console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
* });
* // Later, when you want to close the server.
* controller.abort();
* ```
* @since v0.11.13
* @param options Available options are:
* @param callback Attached as a listener for `'message'` events. Optional.
*/
function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
/**
* Encapsulates the datagram functionality.
*
* New instances of `dgram.Socket` are created using {@link createSocket}.
* The `new` keyword is not to be used to create `dgram.Socket` instances.
* @since v0.1.99
*/
class Socket extends EventEmitter {
/**
* Tells the kernel to join a multicast group at the given `multicastAddress` and`multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the`multicastInterface` argument is not
* specified, the operating system will choose
* one interface and will add membership to it. To add membership to every
* available interface, call `addMembership` multiple times, once per interface.
*
* When called on an unbound socket, this method will implicitly bind to a random
* port, listening on all interfaces.
*
* When sharing a UDP socket across multiple `cluster` workers, the`socket.addMembership()` function must be called only once or an`EADDRINUSE` error will occur:
*
* ```js
* import cluster from 'cluster';
* import dgram from 'dgram';
*
* if (cluster.isPrimary) {
* cluster.fork(); // Works ok.
* cluster.fork(); // Fails with EADDRINUSE.
* } else {
* const s = dgram.createSocket('udp4');
* s.bind(1234, () => {
* s.addMembership('224.0.0.114');
* });
* }
* ```
* @since v0.6.9
*/
addMembership(multicastAddress: string, multicastInterface?: string): void;
/**
* Returns an object containing the address information for a socket.
* For UDP sockets, this object will contain `address`, `family` and `port`properties.
*
* This method throws `EBADF` if called on an unbound socket.
* @since v0.1.99
*/
address(): AddressInfo;
/**
* For UDP sockets, causes the `dgram.Socket` to listen for datagram
* messages on a named `port` and optional `address`. If `port` is not
* specified or is `0`, the operating system will attempt to bind to a
* random port. If `address` is not specified, the operating system will
* attempt to listen on all addresses. Once binding is complete, a`'listening'` event is emitted and the optional `callback` function is
* called.
*
* Specifying both a `'listening'` event listener and passing a`callback` to the `socket.bind()` method is not harmful but not very
* useful.
*
* A bound datagram socket keeps the Node.js process running to receive
* datagram messages.
*
* If binding fails, an `'error'` event is generated. In rare case (e.g.
* attempting to bind with a closed socket), an `Error` may be thrown.
*
* Example of a UDP server listening on port 41234:
*
* ```js
* import dgram from 'dgram';
*
* const server = dgram.createSocket('udp4');
*
* server.on('error', (err) => {
* console.log(`server error:\n${err.stack}`);
* server.close();
* });
*
* server.on('message', (msg, rinfo) => {
* console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
* });
*
* server.on('listening', () => {
* const address = server.address();
* console.log(`server listening ${address.address}:${address.port}`);
* });
*
* server.bind(41234);
* // Prints: server listening 0.0.0.0:41234
* ```
* @since v0.1.99
* @param callback with no parameters. Called when binding is complete.
*/
bind(port?: number, address?: string, callback?: () => void): this;
bind(port?: number, callback?: () => void): this;
bind(callback?: () => void): this;
bind(options: BindOptions, callback?: () => void): this;
/**
* Close the underlying socket and stop listening for data on it. If a callback is
* provided, it is added as a listener for the `'close'` event.
* @since v0.1.99
* @param callback Called when the socket has been closed.
*/
close(callback?: () => void): this;
/**
* Associates the `dgram.Socket` to a remote address and port. Every
* message sent by this handle is automatically sent to that destination. Also,
* the socket will only receive messages from that remote peer.
* Trying to call `connect()` on an already connected socket will result
* in an `ERR_SOCKET_DGRAM_IS_CONNECTED` exception. If `address` is not
* provided, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets)
* will be used by default. Once the connection is complete, a `'connect'` event
* is emitted and the optional `callback` function is called. In case of failure,
* the `callback` is called or, failing this, an `'error'` event is emitted.
* @since v12.0.0
* @param callback Called when the connection is completed or on error.
*/
connect(port: number, address?: string, callback?: () => void): void;
connect(port: number, callback: () => void): void;
/**
* A synchronous function that disassociates a connected `dgram.Socket` from
* its remote address. Trying to call `disconnect()` on an unbound or already
* disconnected socket will result in an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception.
* @since v12.0.0
*/
disconnect(): void;
/**
* Instructs the kernel to leave a multicast group at `multicastAddress` using the`IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
* kernel when the socket is closed or the process terminates, so most apps will
* never have reason to call this.
*
* If `multicastInterface` is not specified, the operating system will attempt to
* drop membership on all valid interfaces.
* @since v0.6.9
*/
dropMembership(multicastAddress: string, multicastInterface?: string): void;
/**
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
* @since v8.7.0
* @return the `SO_RCVBUF` socket receive buffer size in bytes.
*/
getRecvBufferSize(): number;
/**
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
* @since v8.7.0
* @return the `SO_SNDBUF` socket send buffer size in bytes.
*/
getSendBufferSize(): number;
/**
* By default, binding a socket will cause it to block the Node.js process from
* exiting as long as the socket is open. The `socket.unref()` method can be used
* to exclude the socket from the reference counting that keeps the Node.js
* process active. The `socket.ref()` method adds the socket back to the reference
* counting and restores the default behavior.
*
* Calling `socket.ref()` multiples times will have no additional effect.
*
* The `socket.ref()` method returns a reference to the socket so calls can be
* chained.
* @since v0.9.1
*/
ref(): this;
/**
* Returns an object containing the `address`, `family`, and `port` of the remote
* endpoint. This method throws an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception
* if the socket is not connected.
* @since v12.0.0
*/
remoteAddress(): AddressInfo;
/**
* Broadcasts a datagram on the socket.
* For connectionless sockets, the destination `port` and `address` must be
* specified. Connected sockets, on the other hand, will use their associated
* remote endpoint, so the `port` and `address` arguments must not be set.
*
* The `msg` argument contains the message to be sent.
* Depending on its type, different behavior can apply. If `msg` is a `Buffer`,
* any `TypedArray` or a `DataView`,
* the `offset` and `length` specify the offset within the `Buffer` where the
* message begins and the number of bytes in the message, respectively.
* If `msg` is a `String`, then it is automatically converted to a `Buffer`with `'utf8'` encoding. With messages that
* contain multi-byte characters, `offset` and `length` will be calculated with
* respect to `byte length` and not the character position.
* If `msg` is an array, `offset` and `length` must not be specified.
*
* The `address` argument is a string. If the value of `address` is a host name,
* DNS will be used to resolve the address of the host. If `address` is not
* provided or otherwise falsy, `'127.0.0.1'` (for `udp4` sockets) or `'::1'`(for `udp6` sockets) will be used by default.
*
* If the socket has not been previously bound with a call to `bind`, the socket
* is assigned a random port number and is bound to the "all interfaces" address
* (`'0.0.0.0'` for `udp4` sockets, `'::0'` for `udp6` sockets.)
*
* An optional `callback` function may be specified to as a way of reporting
* DNS errors or for determining when it is safe to reuse the `buf` object.
* DNS lookups delay the time to send for at least one tick of the
* Node.js event loop.
*
* The only way to know for sure that the datagram has been sent is by using a`callback`. If an error occurs and a `callback` is given, the error will be
* passed as the first argument to the `callback`. If a `callback` is not given,
* the error is emitted as an `'error'` event on the `socket` object.
*
* Offset and length are optional but both _must_ be set if either are used.
* They are supported only when the first argument is a `Buffer`, a `TypedArray`,
* or a `DataView`.
*
* This method throws `ERR_SOCKET_BAD_PORT` if called on an unbound socket.
*
* Example of sending a UDP packet to a port on `localhost`;
*
* ```js
* import dgram from 'dgram';
* import { Buffer } from 'buffer';
*
* const message = Buffer.from('Some bytes');
* const client = dgram.createSocket('udp4');
* client.send(message, 41234, 'localhost', (err) => {
* client.close();
* });
* ```
*
* Example of sending a UDP packet composed of multiple buffers to a port on`127.0.0.1`;
*
* ```js
* import dgram from 'dgram';
* import { Buffer } from 'buffer';
*
* const buf1 = Buffer.from('Some ');
* const buf2 = Buffer.from('bytes');
* const client = dgram.createSocket('udp4');
* client.send([buf1, buf2], 41234, (err) => {
* client.close();
* });
* ```
*
* Sending multiple buffers might be faster or slower depending on the
* application and operating system. Run benchmarks to
* determine the optimal strategy on a case-by-case basis. Generally speaking,
* however, sending multiple buffers is faster.
*
* Example of sending a UDP packet using a socket connected to a port on`localhost`:
*
* ```js
* import dgram from 'dgram';
* import { Buffer } from 'buffer';
*
* const message = Buffer.from('Some bytes');
* const client = dgram.createSocket('udp4');
* client.connect(41234, 'localhost', (err) => {
* client.send(message, (err) => {
* client.close();
* });
* });
* ```
* @since v0.1.99
* @param msg Message to be sent.
* @param offset Offset in the buffer where the message starts.
* @param length Number of bytes in the message.
* @param port Destination port.
* @param address Destination host name or IP address.
* @param callback Called when the message has been sent.
*/
send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
send(msg: string | Uint8Array | ReadonlyArray<any>, callback?: (error: Error | null, bytes: number) => void): void;
send(msg: string | Uint8Array, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
send(msg: string | Uint8Array, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;
/**
* Sets or clears the `SO_BROADCAST` socket option. When set to `true`, UDP
* packets may be sent to a local interface's broadcast address.
*
* This method throws `EBADF` if called on an unbound socket.
* @since v0.6.9
*/
setBroadcast(flag: boolean): void;
/**
* _All references to scope in this section are referring to [IPv6 Zone Indices](https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses), which are defined by [RFC
* 4007](https://tools.ietf.org/html/rfc4007). In string form, an IP_
* _with a scope index is written as `'IP%scope'` where scope is an interface name_
* _or interface number._
*
* Sets the default outgoing multicast interface of the socket to a chosen
* interface or back to system interface selection. The `multicastInterface` must
* be a valid string representation of an IP from the socket's family.
*
* For IPv4 sockets, this should be the IP configured for the desired physical
* interface. All packets sent to multicast on the socket will be sent on the
* interface determined by the most recent successful use of this call.
*
* For IPv6 sockets, `multicastInterface` should include a scope to indicate the
* interface as in the examples that follow. In IPv6, individual `send` calls can
* also use explicit scope in addresses, so only packets sent to a multicast
* address without specifying an explicit scope are affected by the most recent
* successful use of this call.
*
* This method throws `EBADF` if called on an unbound socket.
*
* #### Example: IPv6 outgoing multicast interface
*
* On most systems, where scope format uses the interface name:
*
* ```js
* const socket = dgram.createSocket('udp6');
*
* socket.bind(1234, () => {
* socket.setMulticastInterface('::%eth1');
* });
* ```
*
* On Windows, where scope format uses an interface number:
*
* ```js
* const socket = dgram.createSocket('udp6');
*
* socket.bind(1234, () => {
* socket.setMulticastInterface('::%2');
* });
* ```
*
* #### Example: IPv4 outgoing multicast interface
*
* All systems use an IP of the host on the desired physical interface:
*
* ```js
* const socket = dgram.createSocket('udp4');
*
* socket.bind(1234, () => {
* socket.setMulticastInterface('10.0.0.2');
* });
* ```
* @since v8.6.0
*/
setMulticastInterface(multicastInterface: string): void;
/**
* Sets or clears the `IP_MULTICAST_LOOP` socket option. When set to `true`,
* multicast packets will also be received on the local interface.
*
* This method throws `EBADF` if called on an unbound socket.
* @since v0.3.8
*/
setMulticastLoopback(flag: boolean): boolean;
/**
* Sets the `IP_MULTICAST_TTL` socket option. While TTL generally stands for
* "Time to Live", in this context it specifies the number of IP hops that a
* packet is allowed to travel through, specifically for multicast traffic. Each
* router or gateway that forwards a packet decrements the TTL. If the TTL is
* decremented to 0 by a router, it will not be forwarded.
*
* The `ttl` argument may be between 0 and 255\. The default on most systems is `1`.
*
* This method throws `EBADF` if called on an unbound socket.
* @since v0.3.8
*/
setMulticastTTL(ttl: number): number;
/**
* Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer
* in bytes.
*
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
* @since v8.7.0
*/
setRecvBufferSize(size: number): void;
/**
* Sets the `SO_SNDBUF` socket option. Sets the maximum socket send buffer
* in bytes.
*
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
* @since v8.7.0
*/
setSendBufferSize(size: number): void;
/**
* Sets the `IP_TTL` socket option. While TTL generally stands for "Time to Live",
* in this context it specifies the number of IP hops that a packet is allowed to
* travel through. Each router or gateway that forwards a packet decrements the
* TTL. If the TTL is decremented to 0 by a router, it will not be forwarded.
* Changing TTL values is typically done for network probes or when multicasting.
*
* The `ttl` argument may be between between 1 and 255\. The default on most systems
* is 64.
*
* This method throws `EBADF` if called on an unbound socket.
* @since v0.1.101
*/
setTTL(ttl: number): number;
/**
* By default, binding a socket will cause it to block the Node.js process from
* exiting as long as the socket is open. The `socket.unref()` method can be used
* to exclude the socket from the reference counting that keeps the Node.js
* process active, allowing the process to exit even if the socket is still
* listening.
*
* Calling `socket.unref()` multiple times will have no addition effect.
*
* The `socket.unref()` method returns a reference to the socket so calls can be
* chained.
* @since v0.9.1
*/
unref(): this;
/**
* Tells the kernel to join a source-specific multicast channel at the given
* `sourceAddress` and `groupAddress`, using the `multicastInterface` with the
* `IP_ADD_SOURCE_MEMBERSHIP` socket option.
* If the `multicastInterface` argument
* Tells the kernel to join a source-specific multicast channel at the given`sourceAddress` and `groupAddress`, using the `multicastInterface` with the`IP_ADD_SOURCE_MEMBERSHIP` socket
* option. If the `multicastInterface` argument
* is not specified, the operating system will choose one interface and will add
* membership to it.
* To add membership to every available interface, call
* `socket.addSourceSpecificMembership()` multiple times, once per interface.
* membership to it. To add membership to every available interface, call`socket.addSourceSpecificMembership()` multiple times, once per interface.
*
* When called on an unbound socket, this method will implicitly bind to a random
* port, listening on all interfaces.
* @since v13.1.0, v12.16.0
*/
addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
/**
* Instructs the kernel to leave a source-specific multicast channel at the given
* `sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`
* socket option. This method is automatically called by the kernel when the
* Instructs the kernel to leave a source-specific multicast channel at the given`sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`socket option. This method is
* automatically called by the kernel when the
* socket is closed or the process terminates, so most apps will never have
* reason to call this.
*
* If `multicastInterface` is not specified, the operating system will attempt to
* drop membership on all valid interfaces.
* @since v13.1.0, v12.16.0
*/
dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
/**
* events.EventEmitter
* 1. close
@ -100,46 +506,41 @@ declare module 'dgram' {
* 5. message
*/
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "close", listener: () => void): this;
addListener(event: "connect", listener: () => void): this;
addListener(event: "error", listener: (err: Error) => void): this;
addListener(event: "listening", listener: () => void): this;
addListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
addListener(event: 'close', listener: () => void): this;
addListener(event: 'connect', listener: () => void): this;
addListener(event: 'error', listener: (err: Error) => void): this;
addListener(event: 'listening', listener: () => void): this;
addListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "close"): boolean;
emit(event: "connect"): boolean;
emit(event: "error", err: Error): boolean;
emit(event: "listening"): boolean;
emit(event: "message", msg: Buffer, rinfo: RemoteInfo): boolean;
emit(event: 'close'): boolean;
emit(event: 'connect'): boolean;
emit(event: 'error', err: Error): boolean;
emit(event: 'listening'): boolean;
emit(event: 'message', msg: Buffer, rinfo: RemoteInfo): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "close", listener: () => void): this;
on(event: "connect", listener: () => void): this;
on(event: "error", listener: (err: Error) => void): this;
on(event: "listening", listener: () => void): this;
on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
on(event: 'close', listener: () => void): this;
on(event: 'connect', listener: () => void): this;
on(event: 'error', listener: (err: Error) => void): this;
on(event: 'listening', listener: () => void): this;
on(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "close", listener: () => void): this;
once(event: "connect", listener: () => void): this;
once(event: "error", listener: (err: Error) => void): this;
once(event: "listening", listener: () => void): this;
once(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
once(event: 'close', listener: () => void): this;
once(event: 'connect', listener: () => void): this;
once(event: 'error', listener: (err: Error) => void): this;
once(event: 'listening', listener: () => void): this;
once(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "close", listener: () => void): this;
prependListener(event: "connect", listener: () => void): this;
prependListener(event: "error", listener: (err: Error) => void): this;
prependListener(event: "listening", listener: () => void): this;
prependListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
prependListener(event: 'close', listener: () => void): this;
prependListener(event: 'connect', listener: () => void): this;
prependListener(event: 'error', listener: (err: Error) => void): this;
prependListener(event: 'listening', listener: () => void): this;
prependListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "close", listener: () => void): this;
prependOnceListener(event: "connect", listener: () => void): this;
prependOnceListener(event: "error", listener: (err: Error) => void): this;
prependOnceListener(event: "listening", listener: () => void): this;
prependOnceListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
prependOnceListener(event: 'close', listener: () => void): this;
prependOnceListener(event: 'connect', listener: () => void): this;
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
prependOnceListener(event: 'listening', listener: () => void): this;
prependOnceListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
}
}
declare module 'node:dgram' {

155
packages/node_modules/@node-red/editor-client/src/types/node/diagnostics_channel.d.ts vendored Normal file
View File

@ -0,0 +1,155 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `diagnostics_channel` module provides an API to create named channels
* to report arbitrary message data for diagnostics purposes.
*
* It can be accessed using:
*
* ```js
* import diagnostics_channel from 'diagnostics_channel';
* ```
*
* It is intended that a module writer wanting to report diagnostics messages
* will create one or many top-level channels to report messages through.
* Channels may also be acquired at runtime but it is not encouraged
* due to the additional overhead of doing so. Channels may be exported for
* convenience, but as long as the name is known it can be acquired anywhere.
*
* If you intend for your module to produce diagnostics data for others to
* consume it is recommended that you include documentation of what named
* channels are used along with the shape of the message data. Channel names
* should generally include the module name to avoid collisions with data from
* other modules.
* @experimental
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/diagnostics_channel.js)
*/
declare module 'diagnostics_channel' {
/**
* Check if there are active subscribers to the named channel. This is helpful if
* the message you want to send might be expensive to prepare.
*
* This API is optional but helpful when trying to publish messages from very
* performance-sensitive code.
*
* ```js
* import diagnostics_channel from 'diagnostics_channel';
*
* if (diagnostics_channel.hasSubscribers('my-channel')) {
* // There are subscribers, prepare and publish message
* }
* ```
* @since v15.1.0, v14.17.0
* @param name The channel name
* @return If there are active subscribers
*/
function hasSubscribers(name: string | symbol): boolean;
/**
* This is the primary entry-point for anyone wanting to interact with a named
* channel. It produces a channel object which is optimized to reduce overhead at
* publish time as much as possible.
*
* ```js
* import diagnostics_channel from 'diagnostics_channel';
*
* const channel = diagnostics_channel.channel('my-channel');
* ```
* @since v15.1.0, v14.17.0
* @param name The channel name
* @return The named channel object
*/
function channel(name: string | symbol): Channel;
type ChannelListener = (message: unknown, name: string | symbol) => void;
/**
* The class `Channel` represents an individual named channel within the data
* pipeline. It is use to track subscribers and to publish messages when there
* are subscribers present. It exists as a separate object to avoid channel
* lookups at publish time, enabling very fast publish speeds and allowing
* for heavy use while incurring very minimal cost. Channels are created with {@link channel}, constructing a channel directly
* with `new Channel(name)` is not supported.
* @since v15.1.0, v14.17.0
*/
class Channel {
readonly name: string | symbol;
/**
* Check if there are active subscribers to this channel. This is helpful if
* the message you want to send might be expensive to prepare.
*
* This API is optional but helpful when trying to publish messages from very
* performance-sensitive code.
*
* ```js
* import diagnostics_channel from 'diagnostics_channel';
*
* const channel = diagnostics_channel.channel('my-channel');
*
* if (channel.hasSubscribers) {
* // There are subscribers, prepare and publish message
* }
* ```
* @since v15.1.0, v14.17.0
*/
readonly hasSubscribers: boolean;
private constructor(name: string | symbol);
/**
* Publish a message to any subscribers to the channel. This will
* trigger message handlers synchronously so they will execute within
* the same context.
*
* ```js
* import diagnostics_channel from 'diagnostics_channel';
*
* const channel = diagnostics_channel.channel('my-channel');
*
* channel.publish({
* some: 'message'
* });
* ```
* @since v15.1.0, v14.17.0
* @param message The message to send to the channel subscribers
*/
publish(message: unknown): void;
/**
* Register a message handler to subscribe to this channel. This message handler
* will be run synchronously whenever a message is published to the channel. Any
* errors thrown in the message handler will trigger an `'uncaughtException'`.
*
* ```js
* import diagnostics_channel from 'diagnostics_channel';
*
* const channel = diagnostics_channel.channel('my-channel');
*
* channel.subscribe((message, name) => {
* // Received data
* });
* ```
* @since v15.1.0, v14.17.0
* @param onMessage The handler to receive channel messages
*/
subscribe(onMessage: ChannelListener): void;
/**
* Remove a message handler previously registered to this channel with `channel.subscribe(onMessage)`.
*
* ```js
* import diagnostics_channel from 'diagnostics_channel';
*
* const channel = diagnostics_channel.channel('my-channel');
*
* function onMessage(message, name) {
* // Received data
* }
*
* channel.subscribe(onMessage);
*
* channel.unsubscribe(onMessage);
* ```
* @since v15.1.0, v14.17.0
* @param onMessage The previous subscribed handler to remove
*/
unsubscribe(onMessage: ChannelListener): void;
}
}
declare module 'node:diagnostics_channel' {
export * from 'diagnostics_channel';
}

791
packages/node_modules/@node-red/editor-client/src/types/node/dns.d.ts vendored
View File

@ -1,89 +1,194 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `dns` module enables name resolution. For example, use it to look up IP
* addresses of host names.
*
* Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the
* DNS protocol for lookups. {@link lookup} uses the operating system
* facilities to perform name resolution. It may not need to perform any network
* communication. To perform name resolution the way other applications on the same
* system do, use {@link lookup}.
*
* ```js
* const dns = require('dns');
*
* dns.lookup('example.org', (err, address, family) => {
* console.log('address: %j family: IPv%s', address, family);
* });
* // address: "93.184.216.34" family: IPv4
* ```
*
* All other functions in the `dns` module connect to an actual DNS server to
* perform name resolution. They will always use the network to perform DNS
* queries. These functions do not use the same set of configuration files used by {@link lookup} (e.g. `/etc/hosts`). Use these functions to always perform
* DNS queries, bypassing other name-resolution facilities.
*
* ```js
* const dns = require('dns');
*
* dns.resolve4('archive.org', (err, addresses) => {
* if (err) throw err;
*
* console.log(`addresses: ${JSON.stringify(addresses)}`);
*
* addresses.forEach((a) => {
* dns.reverse(a, (err, hostnames) => {
* if (err) {
* throw err;
* }
* console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
* });
* });
* });
* ```
*
* See the `Implementation considerations section` for more information.
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/dns.js)
*/
declare module 'dns' {
import * as dnsPromises from 'node:dns/promises';
// Supported getaddrinfo flags.
const ADDRCONFIG: number;
const V4MAPPED: number;
export const ADDRCONFIG: number;
export const V4MAPPED: number;
/**
* If `dns.V4MAPPED` is specified, return resolved IPv6 addresses as
* well as IPv4 mapped IPv6 addresses.
*/
const ALL: number;
interface LookupOptions {
export const ALL: number;
export interface LookupOptions {
family?: number | undefined;
hints?: number | undefined;
all?: boolean | undefined;
verbatim?: boolean | undefined;
}
interface LookupOneOptions extends LookupOptions {
export interface LookupOneOptions extends LookupOptions {
all?: false | undefined;
}
interface LookupAllOptions extends LookupOptions {
export interface LookupAllOptions extends LookupOptions {
all: true;
}
interface LookupAddress {
export interface LookupAddress {
address: string;
family: number;
}
function lookup(hostname: string, family: number, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
function lookup(hostname: string, options: LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
function lookup(hostname: string, options: LookupAllOptions, callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void): void;
function lookup(hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, address: string | LookupAddress[], family: number) => void): void;
function lookup(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
// NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
namespace lookup {
/**
* Resolves a host name (e.g. `'nodejs.org'`) into the first found A (IPv4) or
* AAAA (IPv6) record. All `option` properties are optional. If `options` is an
* integer, then it must be `4` or `6` – if `options` is not provided, then IPv4
* and IPv6 addresses are both returned if found.
*
* With the `all` option set to `true`, the arguments for `callback` change to`(err, addresses)`, with `addresses` being an array of objects with the
* properties `address` and `family`.
*
* On error, `err` is an `Error` object, where `err.code` is the error code.
* Keep in mind that `err.code` will be set to `'ENOTFOUND'` not only when
* the host name does not exist but also when the lookup fails in other ways
* such as no available file descriptors.
*
* `dns.lookup()` does not necessarily have anything to do with the DNS protocol.
* The implementation uses an operating system facility that can associate names
* with addresses, and vice versa. This implementation can have subtle but
* important consequences on the behavior of any Node.js program. Please take some
* time to consult the `Implementation considerations section` before using`dns.lookup()`.
*
* Example usage:
*
* ```js
* const dns = require('dns');
* const options = {
* family: 6,
* hints: dns.ADDRCONFIG | dns.V4MAPPED,
* };
* dns.lookup('example.com', options, (err, address, family) =>
* console.log('address: %j family: IPv%s', address, family));
* // address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6
*
* // When options.all is true, the result will be an Array.
* options.all = true;
* dns.lookup('example.com', options, (err, addresses) =>
* console.log('addresses: %j', addresses));
* // addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]
* ```
*
* If this method is invoked as its `util.promisify()` ed version, and `all`is not set to `true`, it returns a `Promise` for an `Object` with `address` and`family` properties.
* @since v0.1.90
*/
export function lookup(hostname: string, family: number, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
export function lookup(hostname: string, options: LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
export function lookup(hostname: string, options: LookupAllOptions, callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void): void;
export function lookup(hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, address: string | LookupAddress[], family: number) => void): void;
export function lookup(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void;
export namespace lookup {
function __promisify__(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
function __promisify__(hostname: string, options?: LookupOneOptions | number): Promise<LookupAddress>;
function __promisify__(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
}
function lookupService(address: string, port: number, callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void): void;
namespace lookupService {
function __promisify__(address: string, port: number): Promise<{ hostname: string, service: string }>;
/**
* Resolves the given `address` and `port` into a host name and service using
* the operating system's underlying `getnameinfo` implementation.
*
* If `address` is not a valid IP address, a `TypeError` will be thrown.
* The `port` will be coerced to a number. If it is not a legal port, a `TypeError`will be thrown.
*
* On an error, `err` is an `Error` object, where `err.code` is the error code.
*
* ```js
* const dns = require('dns');
* dns.lookupService('127.0.0.1', 22, (err, hostname, service) => {
* console.log(hostname, service);
* // Prints: localhost ssh
* });
* ```
*
* If this method is invoked as its `util.promisify()` ed version, it returns a`Promise` for an `Object` with `hostname` and `service` properties.
* @since v0.11.14
*/
export function lookupService(address: string, port: number, callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void): void;
export namespace lookupService {
function __promisify__(
address: string,
port: number
): Promise<{
hostname: string;
service: string;
}>;
}
interface ResolveOptions {
export interface ResolveOptions {
ttl: boolean;
}
interface ResolveWithTtlOptions extends ResolveOptions {
export interface ResolveWithTtlOptions extends ResolveOptions {
ttl: true;
}
interface RecordWithTtl {
export interface RecordWithTtl {
address: string;
ttl: number;
}
/** @deprecated Use `AnyARecord` or `AnyAaaaRecord` instead. */
type AnyRecordWithTtl = AnyARecord | AnyAaaaRecord;
interface AnyARecord extends RecordWithTtl {
type: "A";
export type AnyRecordWithTtl = AnyARecord | AnyAaaaRecord;
export interface AnyARecord extends RecordWithTtl {
type: 'A';
}
interface AnyAaaaRecord extends RecordWithTtl {
type: "AAAA";
export interface AnyAaaaRecord extends RecordWithTtl {
type: 'AAAA';
}
interface MxRecord {
export interface CaaRecord {
critial: number;
issue?: string | undefined;
issuewild?: string | undefined;
iodef?: string | undefined;
contactemail?: string | undefined;
contactphone?: string | undefined;
}
export interface MxRecord {
priority: number;
exchange: string;
}
interface AnyMxRecord extends MxRecord {
type: "MX";
export interface AnyMxRecord extends MxRecord {
type: 'MX';
}
interface NaptrRecord {
export interface NaptrRecord {
flags: string;
service: string;
regexp: string;
@ -91,12 +196,10 @@ declare module 'dns' {
order: number;
preference: number;
}
interface AnyNaptrRecord extends NaptrRecord {
type: "NAPTR";
export interface AnyNaptrRecord extends NaptrRecord {
type: 'NAPTR';
}
interface SoaRecord {
export interface SoaRecord {
nsname: string;
hostmaster: string;
serial: number;
@ -105,188 +208,415 @@ declare module 'dns' {
expire: number;
minttl: number;
}
interface AnySoaRecord extends SoaRecord {
type: "SOA";
export interface AnySoaRecord extends SoaRecord {
type: 'SOA';
}
interface SrvRecord {
export interface SrvRecord {
priority: number;
weight: number;
port: number;
name: string;
}
interface AnySrvRecord extends SrvRecord {
type: "SRV";
export interface AnySrvRecord extends SrvRecord {
type: 'SRV';
}
interface AnyTxtRecord {
type: "TXT";
export interface AnyTxtRecord {
type: 'TXT';
entries: string[];
}
interface AnyNsRecord {
type: "NS";
export interface AnyNsRecord {
type: 'NS';
value: string;
}
interface AnyPtrRecord {
type: "PTR";
export interface AnyPtrRecord {
type: 'PTR';
value: string;
}
interface AnyCnameRecord {
type: "CNAME";
export interface AnyCnameRecord {
type: 'CNAME';
value: string;
}
type AnyRecord = AnyARecord |
AnyAaaaRecord |
AnyCnameRecord |
AnyMxRecord |
AnyNaptrRecord |
AnyNsRecord |
AnyPtrRecord |
AnySoaRecord |
AnySrvRecord |
AnyTxtRecord;
function resolve(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve(hostname: string, rrtype: "A", callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve(hostname: string, rrtype: "AAAA", callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve(hostname: string, rrtype: "ANY", callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
function resolve(hostname: string, rrtype: "CNAME", callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve(hostname: string, rrtype: "MX", callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
function resolve(hostname: string, rrtype: "NAPTR", callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
function resolve(hostname: string, rrtype: "NS", callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve(hostname: string, rrtype: "PTR", callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve(hostname: string, rrtype: "SOA", callback: (err: NodeJS.ErrnoException | null, addresses: SoaRecord) => void): void;
function resolve(hostname: string, rrtype: "SRV", callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
function resolve(hostname: string, rrtype: "TXT", callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
function resolve(
export type AnyRecord = AnyARecord | AnyAaaaRecord | AnyCnameRecord | AnyMxRecord | AnyNaptrRecord | AnyNsRecord | AnyPtrRecord | AnySoaRecord | AnySrvRecord | AnyTxtRecord;
/**
* Uses the DNS protocol to resolve a host name (e.g. `'nodejs.org'`) into an array
* of the resource records. The `callback` function has arguments`(err, records)`. When successful, `records` will be an array of resource
* records. The type and structure of individual results varies based on `rrtype`:
*
* <omitted>
*
* On error, `err` is an `Error` object, where `err.code` is one of the `DNS error codes`.
* @since v0.1.27
* @param hostname Host name to resolve.
* @param [rrtype='A'] Resource record type.
*/
export function resolve(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve(hostname: string, rrtype: 'A', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve(hostname: string, rrtype: 'AAAA', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve(hostname: string, rrtype: 'ANY', callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
export function resolve(hostname: string, rrtype: 'CNAME', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve(hostname: string, rrtype: 'MX', callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
export function resolve(hostname: string, rrtype: 'NAPTR', callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
export function resolve(hostname: string, rrtype: 'NS', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve(hostname: string, rrtype: 'PTR', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve(hostname: string, rrtype: 'SOA', callback: (err: NodeJS.ErrnoException | null, addresses: SoaRecord) => void): void;
export function resolve(hostname: string, rrtype: 'SRV', callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
export function resolve(hostname: string, rrtype: 'TXT', callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
export function resolve(
hostname: string,
rrtype: string,
callback: (err: NodeJS.ErrnoException | null, addresses: string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]) => void,
callback: (err: NodeJS.ErrnoException | null, addresses: string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]) => void
): void;
// NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
namespace resolve {
function __promisify__(hostname: string, rrtype?: "A" | "AAAA" | "CNAME" | "NS" | "PTR"): Promise<string[]>;
function __promisify__(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
function __promisify__(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
function __promisify__(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
function __promisify__(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
function __promisify__(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
function __promisify__(hostname: string, rrtype: "TXT"): Promise<string[][]>;
export namespace resolve {
function __promisify__(hostname: string, rrtype?: 'A' | 'AAAA' | 'CNAME' | 'NS' | 'PTR'): Promise<string[]>;
function __promisify__(hostname: string, rrtype: 'ANY'): Promise<AnyRecord[]>;
function __promisify__(hostname: string, rrtype: 'MX'): Promise<MxRecord[]>;
function __promisify__(hostname: string, rrtype: 'NAPTR'): Promise<NaptrRecord[]>;
function __promisify__(hostname: string, rrtype: 'SOA'): Promise<SoaRecord>;
function __promisify__(hostname: string, rrtype: 'SRV'): Promise<SrvRecord[]>;
function __promisify__(hostname: string, rrtype: 'TXT'): Promise<string[][]>;
function __promisify__(hostname: string, rrtype: string): Promise<string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]>;
}
function resolve4(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve4(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
function resolve4(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
// NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
namespace resolve4 {
/**
* Uses the DNS protocol to resolve a IPv4 addresses (`A` records) for the`hostname`. The `addresses` argument passed to the `callback` function
* will contain an array of IPv4 addresses (e.g.`['74.125.79.104', '74.125.79.105', '74.125.79.106']`).
* @since v0.1.16
* @param hostname Host name to resolve.
*/
export function resolve4(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve4(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
export function resolve4(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
export namespace resolve4 {
function __promisify__(hostname: string): Promise<string[]>;
function __promisify__(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
function __promisify__(hostname: string, options?: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
}
function resolve6(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
function resolve6(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
function resolve6(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
// NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
namespace resolve6 {
/**
* Uses the DNS protocol to resolve a IPv6 addresses (`AAAA` records) for the`hostname`. The `addresses` argument passed to the `callback` function
* will contain an array of IPv6 addresses.
* @since v0.1.16
* @param hostname Host name to resolve.
*/
export function resolve6(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export function resolve6(hostname: string, options: ResolveWithTtlOptions, callback: (err: NodeJS.ErrnoException | null, addresses: RecordWithTtl[]) => void): void;
export function resolve6(hostname: string, options: ResolveOptions, callback: (err: NodeJS.ErrnoException | null, addresses: string[] | RecordWithTtl[]) => void): void;
export namespace resolve6 {
function __promisify__(hostname: string): Promise<string[]>;
function __promisify__(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
function __promisify__(hostname: string, options?: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
}
function resolveCname(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
namespace resolveCname {
/**
* Uses the DNS protocol to resolve `CNAME` records for the `hostname`. The`addresses` argument passed to the `callback` function
* will contain an array of canonical name records available for the `hostname`(e.g. `['bar.example.com']`).
* @since v0.3.2
*/
export function resolveCname(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export namespace resolveCname {
function __promisify__(hostname: string): Promise<string[]>;
}
function resolveMx(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
namespace resolveMx {
/**
* Uses the DNS protocol to resolve `CAA` records for the `hostname`. The`addresses` argument passed to the `callback` function
* will contain an array of certification authority authorization records
* available for the `hostname` (e.g. `[{critical: 0, iodef: 'mailto:pki@example.com'}, {critical: 128, issue: 'pki.example.com'}]`).
* @since v15.0.0
*/
export function resolveCaa(hostname: string, callback: (err: NodeJS.ErrnoException | null, records: CaaRecord[]) => void): void;
export namespace resolveCaa {
function __promisify__(hostname: string): Promise<CaaRecord[]>;
}
/**
* Uses the DNS protocol to resolve mail exchange records (`MX` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
* contain an array of objects containing both a `priority` and `exchange`property (e.g. `[{priority: 10, exchange: 'mx.example.com'}, ...]`).
* @since v0.1.27
*/
export function resolveMx(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void;
export namespace resolveMx {
function __promisify__(hostname: string): Promise<MxRecord[]>;
}
function resolveNaptr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
namespace resolveNaptr {
/**
* Uses the DNS protocol to resolve regular expression based records (`NAPTR`records) for the `hostname`. The `addresses` argument passed to the `callback`function will contain an array of
* objects with the following properties:
*
* * `flags`
* * `service`
* * `regexp`
* * `replacement`
* * `order`
* * `preference`
*
* ```js
* {
* flags: 's',
* service: 'SIP+D2U',
* regexp: '',
* replacement: '_sip._udp.example.com',
* order: 30,
* preference: 100
* }
* ```
* @since v0.9.12
*/
export function resolveNaptr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void;
export namespace resolveNaptr {
function __promisify__(hostname: string): Promise<NaptrRecord[]>;
}
function resolveNs(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
namespace resolveNs {
/**
* Uses the DNS protocol to resolve name server records (`NS` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
* contain an array of name server records available for `hostname`(e.g. `['ns1.example.com', 'ns2.example.com']`).
* @since v0.1.90
*/
export function resolveNs(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export namespace resolveNs {
function __promisify__(hostname: string): Promise<string[]>;
}
function resolvePtr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
namespace resolvePtr {
/**
* Uses the DNS protocol to resolve pointer records (`PTR` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
* be an array of strings containing the reply records.
* @since v6.0.0
*/
export function resolvePtr(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void;
export namespace resolvePtr {
function __promisify__(hostname: string): Promise<string[]>;
}
function resolveSoa(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: SoaRecord) => void): void;
namespace resolveSoa {
/**
* Uses the DNS protocol to resolve a start of authority record (`SOA` record) for
* the `hostname`. The `address` argument passed to the `callback` function will
* be an object with the following properties:
*
* * `nsname`
* * `hostmaster`
* * `serial`
* * `refresh`
* * `retry`
* * `expire`
* * `minttl`
*
* ```js
* {
* nsname: 'ns.example.com',
* hostmaster: 'root.example.com',
* serial: 2013101809,
* refresh: 10000,
* retry: 2400,
* expire: 604800,
* minttl: 3600
* }
* ```
* @since v0.11.10
*/
export function resolveSoa(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: SoaRecord) => void): void;
export namespace resolveSoa {
function __promisify__(hostname: string): Promise<SoaRecord>;
}
function resolveSrv(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
namespace resolveSrv {
/**
* Uses the DNS protocol to resolve service records (`SRV` records) for the`hostname`. The `addresses` argument passed to the `callback` function will
* be an array of objects with the following properties:
*
* * `priority`
* * `weight`
* * `port`
* * `name`
*
* ```js
* {
* priority: 10,
* weight: 5,
* port: 21223,
* name: 'service.example.com'
* }
* ```
* @since v0.1.27
*/
export function resolveSrv(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void;
export namespace resolveSrv {
function __promisify__(hostname: string): Promise<SrvRecord[]>;
}
function resolveTxt(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
namespace resolveTxt {
/**
* Uses the DNS protocol to resolve text queries (`TXT` records) for the`hostname`. The `records` argument passed to the `callback` function is a
* two-dimensional array of the text records available for `hostname` (e.g.`[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]`). Each sub-array contains TXT chunks of
* one record. Depending on the use case, these could be either joined together or
* treated separately.
* @since v0.1.27
*/
export function resolveTxt(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void;
export namespace resolveTxt {
function __promisify__(hostname: string): Promise<string[][]>;
}
function resolveAny(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
namespace resolveAny {
/**
* Uses the DNS protocol to resolve all records (also known as `ANY` or `*` query).
* The `ret` argument passed to the `callback` function will be an array containing
* various types of records. Each object has a property `type` that indicates the
* type of the current record. And depending on the `type`, additional properties
* will be present on the object:
*
* <omitted>
*
* Here is an example of the `ret` object passed to the callback:
*
* ```js
* [ { type: 'A', address: '127.0.0.1', ttl: 299 },
* { type: 'CNAME', value: 'example.com' },
* { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
* { type: 'NS', value: 'ns1.example.com' },
* { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
* { type: 'SOA',
* nsname: 'ns1.example.com',
* hostmaster: 'admin.example.com',
* serial: 156696742,
* refresh: 900,
* retry: 900,
* expire: 1800,
* minttl: 60 } ]
* ```
*
* DNS server operators may choose not to respond to `ANY`queries. It may be better to call individual methods like {@link resolve4},{@link resolveMx}, and so on. For more details, see [RFC
* 8482](https://tools.ietf.org/html/rfc8482).
*/
export function resolveAny(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void;
export namespace resolveAny {
function __promisify__(hostname: string): Promise<AnyRecord[]>;
}
function reverse(ip: string, callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void): void;
function setServers(servers: ReadonlyArray<string>): void;
function getServers(): string[];
function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
/**
* Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
* array of host names.
*
* On error, `err` is an `Error` object, where `err.code` is
* one of the `DNS error codes`.
* @since v0.1.16
*/
export function reverse(ip: string, callback: (err: NodeJS.ErrnoException | null, hostnames: string[]) => void): void;
/**
* Sets the IP address and port of servers to be used when performing DNS
* resolution. The `servers` argument is an array of [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6) formatted
* addresses. If the port is the IANA default DNS port (53) it can be omitted.
*
* ```js
* dns.setServers([
* '4.4.4.4',
* '[2001:4860:4860::8888]',
* '4.4.4.4:1053',
* '[2001:4860:4860::8888]:1053',
* ]);
* ```
*
* An error will be thrown if an invalid address is provided.
*
* The `dns.setServers()` method must not be called while a DNS query is in
* progress.
*
* The {@link setServers} method affects only {@link resolve},`dns.resolve*()` and {@link reverse} (and specifically _not_ {@link lookup}).
*
* This method works much like [resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
* That is, if attempting to resolve with the first server provided results in a`NOTFOUND` error, the `resolve()` method will _not_ attempt to resolve with
* subsequent servers provided. Fallback DNS servers will only be used if the
* earlier ones time out or result in some other error.
* @since v0.11.3
* @param servers array of `RFC 5952` formatted addresses
*/
export function setServers(servers: ReadonlyArray<string>): void;
/**
* Returns an array of IP address strings, formatted according to [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6),
* that are currently configured for DNS resolution. A string will include a port
* section if a custom port is used.
*
* ```js
* [
* '4.4.4.4',
* '2001:4860:4860::8888',
* '4.4.4.4:1053',
* '[2001:4860:4860::8888]:1053',
* ]
* ```
* @since v0.11.3
*/
export function getServers(): string[];
/**
* Set the default value of `verbatim` in {@link lookup}. The value could be:
* - `ipv4first`: sets default `verbatim` `false`.
* - `verbatim`: sets default `verbatim` `true`.
*
* The default is `ipv4first` and {@link setDefaultResultOrder} have higher priority than `--dns-result-order`.
* When using worker threads, {@link setDefaultResultOrder} from the main thread won't affect the default dns orders in workers.
* @since v14.18.0
* @param order must be 'ipv4first' or 'verbatim'.
*/
export function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
// Error codes
const NODATA: string;
const FORMERR: string;
const SERVFAIL: string;
const NOTFOUND: string;
const NOTIMP: string;
const REFUSED: string;
const BADQUERY: string;
const BADNAME: string;
const BADFAMILY: string;
const BADRESP: string;
const CONNREFUSED: string;
const TIMEOUT: string;
const EOF: string;
const FILE: string;
const NOMEM: string;
const DESTRUCTION: string;
const BADSTR: string;
const BADFLAGS: string;
const NONAME: string;
const BADHINTS: string;
const NOTINITIALIZED: string;
const LOADIPHLPAPI: string;
const ADDRGETNETWORKPARAMS: string;
const CANCELLED: string;
interface ResolverOptions {
export const NODATA: string;
export const FORMERR: string;
export const SERVFAIL: string;
export const NOTFOUND: string;
export const NOTIMP: string;
export const REFUSED: string;
export const BADQUERY: string;
export const BADNAME: string;
export const BADFAMILY: string;
export const BADRESP: string;
export const CONNREFUSED: string;
export const TIMEOUT: string;
export const EOF: string;
export const FILE: string;
export const NOMEM: string;
export const DESTRUCTION: string;
export const BADSTR: string;
export const BADFLAGS: string;
export const NONAME: string;
export const BADHINTS: string;
export const NOTINITIALIZED: string;
export const LOADIPHLPAPI: string;
export const ADDRGETNETWORKPARAMS: string;
export const CANCELLED: string;
export interface ResolverOptions {
timeout?: number | undefined;
/**
* @default 4
*/
tries?: number;
}
class Resolver {
/**
* An independent resolver for DNS requests.
*
* Creating a new resolver uses the default server settings. Setting
* the servers used for a resolver using `resolver.setServers()` does not affect
* other resolvers:
*
* ```js
* const { Resolver } = require('dns');
* const resolver = new Resolver();
* resolver.setServers(['4.4.4.4']);
*
* // This request will use the server at 4.4.4.4, independent of global settings.
* resolver.resolve4('example.org', (err, addresses) => {
* // ...
* });
* ```
*
* The following methods from the `dns` module are available:
*
* * `resolver.getServers()`
* * `resolver.resolve()`
* * `resolver.resolve4()`
* * `resolver.resolve6()`
* * `resolver.resolveAny()`
* * `resolver.resolveCaa()`
* * `resolver.resolveCname()`
* * `resolver.resolveMx()`
* * `resolver.resolveNaptr()`
* * `resolver.resolveNs()`
* * `resolver.resolvePtr()`
* * `resolver.resolveSoa()`
* * `resolver.resolveSrv()`
* * `resolver.resolveTxt()`
* * `resolver.reverse()`
* * `resolver.setServers()`
* @since v8.3.0
*/
export class Resolver {
constructor(options?: ResolverOptions);
/**
* Cancel all outstanding DNS queries made by this resolver. The corresponding
* callbacks will be called with an error with code `ECANCELLED`.
* @since v8.3.0
*/
cancel(): void;
getServers: typeof getServers;
resolve: typeof resolve;
@ -302,88 +632,25 @@ declare module 'dns' {
resolveSrv: typeof resolveSrv;
resolveTxt: typeof resolveTxt;
reverse: typeof reverse;
/**
* The resolver instance will send its requests from the specified IP address.
* This allows programs to specify outbound interfaces when used on multi-homed
* systems.
*
* If a v4 or v6 address is not specified, it is set to the default, and the
* operating system will choose a local address automatically.
*
* The resolver will use the v4 local address when making requests to IPv4 DNS
* servers, and the v6 local address when making requests to IPv6 DNS servers.
* The `rrtype` of resolution requests has no impact on the local address used.
* @since v15.1.0
* @param [ipv4='0.0.0.0'] A string representation of an IPv4 address.
* @param [ipv6='::0'] A string representation of an IPv6 address.
*/
setLocalAddress(ipv4?: string, ipv6?: string): void;
setServers: typeof setServers;
}
namespace promises {
function getServers(): string[];
function lookup(hostname: string, family: number): Promise<LookupAddress>;
function lookup(hostname: string, options: LookupOneOptions): Promise<LookupAddress>;
function lookup(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
function lookup(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
function lookup(hostname: string): Promise<LookupAddress>;
function lookupService(address: string, port: number): Promise<{ hostname: string, service: string }>;
function resolve(hostname: string): Promise<string[]>;
function resolve(hostname: string, rrtype: "A"): Promise<string[]>;
function resolve(hostname: string, rrtype: "AAAA"): Promise<string[]>;
function resolve(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
function resolve(hostname: string, rrtype: "CNAME"): Promise<string[]>;
function resolve(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
function resolve(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
function resolve(hostname: string, rrtype: "NS"): Promise<string[]>;
function resolve(hostname: string, rrtype: "PTR"): Promise<string[]>;
function resolve(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
function resolve(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
function resolve(hostname: string, rrtype: "TXT"): Promise<string[][]>;
function resolve(hostname: string, rrtype: string): Promise<string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]>;
function resolve4(hostname: string): Promise<string[]>;
function resolve4(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
function resolve4(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
function resolve6(hostname: string): Promise<string[]>;
function resolve6(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
function resolve6(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
function resolveAny(hostname: string): Promise<AnyRecord[]>;
function resolveCname(hostname: string): Promise<string[]>;
function resolveMx(hostname: string): Promise<MxRecord[]>;
function resolveNaptr(hostname: string): Promise<NaptrRecord[]>;
function resolveNs(hostname: string): Promise<string[]>;
function resolvePtr(hostname: string): Promise<string[]>;
function resolveSoa(hostname: string): Promise<SoaRecord>;
function resolveSrv(hostname: string): Promise<SrvRecord[]>;
function resolveTxt(hostname: string): Promise<string[][]>;
function reverse(ip: string): Promise<string[]>;
function setServers(servers: ReadonlyArray<string>): void;
function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
class Resolver {
constructor(options?: ResolverOptions);
cancel(): void;
getServers: typeof getServers;
resolve: typeof resolve;
resolve4: typeof resolve4;
resolve6: typeof resolve6;
resolveAny: typeof resolveAny;
resolveCname: typeof resolveCname;
resolveMx: typeof resolveMx;
resolveNaptr: typeof resolveNaptr;
resolveNs: typeof resolveNs;
resolvePtr: typeof resolvePtr;
resolveSoa: typeof resolveSoa;
resolveSrv: typeof resolveSrv;
resolveTxt: typeof resolveTxt;
reverse: typeof reverse;
setLocalAddress(ipv4?: string, ipv6?: string): void;
setServers: typeof setServers;
}
}
export { dnsPromises as promises };
}
declare module 'node:dns' {
export * from 'dns';

371
packages/node_modules/@node-red/editor-client/src/types/node/dns/promises.d.ts vendored Normal file
View File

@ -0,0 +1,371 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `dns.promises` API provides an alternative set of asynchronous DNS methods
* that return `Promise` objects rather than using callbacks. The API is accessible
* via `require('dns').promises` or `require('dns/promises')`.
* @since v10.6.0
*/
declare module 'dns/promises' {
import {
LookupAddress,
LookupOneOptions,
LookupAllOptions,
LookupOptions,
AnyRecord,
CaaRecord,
MxRecord,
NaptrRecord,
SoaRecord,
SrvRecord,
ResolveWithTtlOptions,
RecordWithTtl,
ResolveOptions,
ResolverOptions,
} from 'node:dns';
/**
* Returns an array of IP address strings, formatted according to [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6),
* that are currently configured for DNS resolution. A string will include a port
* section if a custom port is used.
*
* ```js
* [
* '4.4.4.4',
* '2001:4860:4860::8888',
* '4.4.4.4:1053',
* '[2001:4860:4860::8888]:1053',
* ]
* ```
* @since v10.6.0
*/
function getServers(): string[];
/**
* Resolves a host name (e.g. `'nodejs.org'`) into the first found A (IPv4) or
* AAAA (IPv6) record. All `option` properties are optional. If `options` is an
* integer, then it must be `4` or `6` – if `options` is not provided, then IPv4
* and IPv6 addresses are both returned if found.
*
* With the `all` option set to `true`, the `Promise` is resolved with `addresses`being an array of objects with the properties `address` and `family`.
*
* On error, the `Promise` is rejected with an `Error` object, where `err.code`is the error code.
* Keep in mind that `err.code` will be set to `'ENOTFOUND'` not only when
* the host name does not exist but also when the lookup fails in other ways
* such as no available file descriptors.
*
* `dnsPromises.lookup()` does not necessarily have anything to do with the DNS
* protocol. The implementation uses an operating system facility that can
* associate names with addresses, and vice versa. This implementation can have
* subtle but important consequences on the behavior of any Node.js program. Please
* take some time to consult the `Implementation considerations section` before
* using `dnsPromises.lookup()`.
*
* Example usage:
*
* ```js
* const dns = require('dns');
* const dnsPromises = dns.promises;
* const options = {
* family: 6,
* hints: dns.ADDRCONFIG | dns.V4MAPPED,
* };
*
* dnsPromises.lookup('example.com', options).then((result) => {
* console.log('address: %j family: IPv%s', result.address, result.family);
* // address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6
* });
*
* // When options.all is true, the result will be an Array.
* options.all = true;
* dnsPromises.lookup('example.com', options).then((result) => {
* console.log('addresses: %j', result);
* // addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}]
* });
* ```
* @since v10.6.0
*/
function lookup(hostname: string, family: number): Promise<LookupAddress>;
function lookup(hostname: string, options: LookupOneOptions): Promise<LookupAddress>;
function lookup(hostname: string, options: LookupAllOptions): Promise<LookupAddress[]>;
function lookup(hostname: string, options: LookupOptions): Promise<LookupAddress | LookupAddress[]>;
function lookup(hostname: string): Promise<LookupAddress>;
/**
* Resolves the given `address` and `port` into a host name and service using
* the operating system's underlying `getnameinfo` implementation.
*
* If `address` is not a valid IP address, a `TypeError` will be thrown.
* The `port` will be coerced to a number. If it is not a legal port, a `TypeError`will be thrown.
*
* On error, the `Promise` is rejected with an `Error` object, where `err.code`is the error code.
*
* ```js
* const dnsPromises = require('dns').promises;
* dnsPromises.lookupService('127.0.0.1', 22).then((result) => {
* console.log(result.hostname, result.service);
* // Prints: localhost ssh
* });
* ```
* @since v10.6.0
*/
function lookupService(
address: string,
port: number
): Promise<{
hostname: string;
service: string;
}>;
/**
* Uses the DNS protocol to resolve a host name (e.g. `'nodejs.org'`) into an array
* of the resource records. When successful, the `Promise` is resolved with an
* array of resource records. The type and structure of individual results vary
* based on `rrtype`:
*
* <omitted>
*
* On error, the `Promise` is rejected with an `Error` object, where `err.code`is one of the `DNS error codes`.
* @since v10.6.0
* @param hostname Host name to resolve.
* @param [rrtype='A'] Resource record type.
*/
function resolve(hostname: string): Promise<string[]>;
function resolve(hostname: string, rrtype: 'A'): Promise<string[]>;
function resolve(hostname: string, rrtype: 'AAAA'): Promise<string[]>;
function resolve(hostname: string, rrtype: 'ANY'): Promise<AnyRecord[]>;
function resolve(hostname: string, rrtype: 'CAA'): Promise<CaaRecord[]>;
function resolve(hostname: string, rrtype: 'CNAME'): Promise<string[]>;
function resolve(hostname: string, rrtype: 'MX'): Promise<MxRecord[]>;
function resolve(hostname: string, rrtype: 'NAPTR'): Promise<NaptrRecord[]>;
function resolve(hostname: string, rrtype: 'NS'): Promise<string[]>;
function resolve(hostname: string, rrtype: 'PTR'): Promise<string[]>;
function resolve(hostname: string, rrtype: 'SOA'): Promise<SoaRecord>;
function resolve(hostname: string, rrtype: 'SRV'): Promise<SrvRecord[]>;
function resolve(hostname: string, rrtype: 'TXT'): Promise<string[][]>;
function resolve(hostname: string, rrtype: string): Promise<string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]>;
/**
* Uses the DNS protocol to resolve IPv4 addresses (`A` records) for the`hostname`. On success, the `Promise` is resolved with an array of IPv4
* addresses (e.g. `['74.125.79.104', '74.125.79.105', '74.125.79.106']`).
* @since v10.6.0
* @param hostname Host name to resolve.
*/
function resolve4(hostname: string): Promise<string[]>;
function resolve4(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
function resolve4(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
/**
* Uses the DNS protocol to resolve IPv6 addresses (`AAAA` records) for the`hostname`. On success, the `Promise` is resolved with an array of IPv6
* addresses.
* @since v10.6.0
* @param hostname Host name to resolve.
*/
function resolve6(hostname: string): Promise<string[]>;
function resolve6(hostname: string, options: ResolveWithTtlOptions): Promise<RecordWithTtl[]>;
function resolve6(hostname: string, options: ResolveOptions): Promise<string[] | RecordWithTtl[]>;
/**
* Uses the DNS protocol to resolve all records (also known as `ANY` or `*` query).
* On success, the `Promise` is resolved with an array containing various types of
* records. Each object has a property `type` that indicates the type of the
* current record. And depending on the `type`, additional properties will be
* present on the object:
*
* <omitted>
*
* Here is an example of the result object:
*
* ```js
* [ { type: 'A', address: '127.0.0.1', ttl: 299 },
* { type: 'CNAME', value: 'example.com' },
* { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
* { type: 'NS', value: 'ns1.example.com' },
* { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] },
* { type: 'SOA',
* nsname: 'ns1.example.com',
* hostmaster: 'admin.example.com',
* serial: 156696742,
* refresh: 900,
* retry: 900,
* expire: 1800,
* minttl: 60 } ]
* ```
* @since v10.6.0
*/
function resolveAny(hostname: string): Promise<AnyRecord[]>;
/**
* Uses the DNS protocol to resolve `CAA` records for the `hostname`. On success,
* the `Promise` is resolved with an array of objects containing available
* certification authority authorization records available for the `hostname`(e.g. `[{critical: 0, iodef: 'mailto:pki@example.com'},{critical: 128, issue: 'pki.example.com'}]`).
* @since v15.0.0
*/
function resolveCaa(hostname: string): Promise<CaaRecord[]>;
/**
* Uses the DNS protocol to resolve `CNAME` records for the `hostname`. On success,
* the `Promise` is resolved with an array of canonical name records available for
* the `hostname` (e.g. `['bar.example.com']`).
* @since v10.6.0
*/
function resolveCname(hostname: string): Promise<string[]>;
/**
* Uses the DNS protocol to resolve mail exchange records (`MX` records) for the`hostname`. On success, the `Promise` is resolved with an array of objects
* containing both a `priority` and `exchange` property (e.g.`[{priority: 10, exchange: 'mx.example.com'}, ...]`).
* @since v10.6.0
*/
function resolveMx(hostname: string): Promise<MxRecord[]>;
/**
* Uses the DNS protocol to resolve regular expression based records (`NAPTR`records) for the `hostname`. On success, the `Promise` is resolved with an array
* of objects with the following properties:
*
* * `flags`
* * `service`
* * `regexp`
* * `replacement`
* * `order`
* * `preference`
*
* ```js
* {
* flags: 's',
* service: 'SIP+D2U',
* regexp: '',
* replacement: '_sip._udp.example.com',
* order: 30,
* preference: 100
* }
* ```
* @since v10.6.0
*/
function resolveNaptr(hostname: string): Promise<NaptrRecord[]>;
/**
* Uses the DNS protocol to resolve name server records (`NS` records) for the`hostname`. On success, the `Promise` is resolved with an array of name server
* records available for `hostname` (e.g.`['ns1.example.com', 'ns2.example.com']`).
* @since v10.6.0
*/
function resolveNs(hostname: string): Promise<string[]>;
/**
* Uses the DNS protocol to resolve pointer records (`PTR` records) for the`hostname`. On success, the `Promise` is resolved with an array of strings
* containing the reply records.
* @since v10.6.0
*/
function resolvePtr(hostname: string): Promise<string[]>;
/**
* Uses the DNS protocol to resolve a start of authority record (`SOA` record) for
* the `hostname`. On success, the `Promise` is resolved with an object with the
* following properties:
*
* * `nsname`
* * `hostmaster`
* * `serial`
* * `refresh`
* * `retry`
* * `expire`
* * `minttl`
*
* ```js
* {
* nsname: 'ns.example.com',
* hostmaster: 'root.example.com',
* serial: 2013101809,
* refresh: 10000,
* retry: 2400,
* expire: 604800,
* minttl: 3600
* }
* ```
* @since v10.6.0
*/
function resolveSoa(hostname: string): Promise<SoaRecord>;
/**
* Uses the DNS protocol to resolve service records (`SRV` records) for the`hostname`. On success, the `Promise` is resolved with an array of objects with
* the following properties:
*
* * `priority`
* * `weight`
* * `port`
* * `name`
*
* ```js
* {
* priority: 10,
* weight: 5,
* port: 21223,
* name: 'service.example.com'
* }
* ```
* @since v10.6.0
*/
function resolveSrv(hostname: string): Promise<SrvRecord[]>;
/**
* Uses the DNS protocol to resolve text queries (`TXT` records) for the`hostname`. On success, the `Promise` is resolved with a two-dimensional array
* of the text records available for `hostname` (e.g.`[ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]`). Each sub-array contains TXT chunks of
* one record. Depending on the use case, these could be either joined together or
* treated separately.
* @since v10.6.0
*/
function resolveTxt(hostname: string): Promise<string[][]>;
/**
* Performs a reverse DNS query that resolves an IPv4 or IPv6 address to an
* array of host names.
*
* On error, the `Promise` is rejected with an `Error` object, where `err.code`is one of the `DNS error codes`.
* @since v10.6.0
*/
function reverse(ip: string): Promise<string[]>;
/**
* Sets the IP address and port of servers to be used when performing DNS
* resolution. The `servers` argument is an array of [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6) formatted
* addresses. If the port is the IANA default DNS port (53) it can be omitted.
*
* ```js
* dnsPromises.setServers([
* '4.4.4.4',
* '[2001:4860:4860::8888]',
* '4.4.4.4:1053',
* '[2001:4860:4860::8888]:1053',
* ]);
* ```
*
* An error will be thrown if an invalid address is provided.
*
* The `dnsPromises.setServers()` method must not be called while a DNS query is in
* progress.
*
* This method works much like [resolve.conf](https://man7.org/linux/man-pages/man5/resolv.conf.5.html).
* That is, if attempting to resolve with the first server provided results in a`NOTFOUND` error, the `resolve()` method will _not_ attempt to resolve with
* subsequent servers provided. Fallback DNS servers will only be used if the
* earlier ones time out or result in some other error.
* @since v10.6.0
* @param servers array of `RFC 5952` formatted addresses
*/
function setServers(servers: ReadonlyArray<string>): void;
/**
* Set the default value of `verbatim` in {@link lookup}. The value could be:
* - `ipv4first`: sets default `verbatim` `false`.
* - `verbatim`: sets default `verbatim` `true`.
*
* The default is `ipv4first` and {@link setDefaultResultOrder} have higher priority than `--dns-result-order`.
* When using worker threads, {@link setDefaultResultOrder} from the main thread won't affect the default dns orders in workers.
* @since v14.18.0
* @param order must be 'ipv4first' or 'verbatim'.
*/
function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void;
class Resolver {
constructor(options?: ResolverOptions);
cancel(): void;
getServers: typeof getServers;
resolve: typeof resolve;
resolve4: typeof resolve4;
resolve6: typeof resolve6;
resolveAny: typeof resolveAny;
resolveCname: typeof resolveCname;
resolveMx: typeof resolveMx;
resolveNaptr: typeof resolveNaptr;
resolveNs: typeof resolveNs;
resolvePtr: typeof resolvePtr;
resolveSoa: typeof resolveSoa;
resolveSrv: typeof resolveSrv;
resolveTxt: typeof resolveTxt;
reverse: typeof reverse;
setLocalAddress(ipv4?: string, ipv6?: string): void;
setServers: typeof setServers;
}
}
declare module 'node:dns/promises' {
export * from 'dns/promises';
}

175
packages/node_modules/@node-red/editor-client/src/types/node/domain.d.ts vendored
View File

@ -1,28 +1,171 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* **This module is pending deprecation.** Once a replacement API has been
* finalized, this module will be fully deprecated. Most developers should
* **not** have cause to use this module. Users who absolutely must have
* the functionality that domains provide may rely on it for the time being
* but should expect to have to migrate to a different solution
* in the future.
*
* Domains provide a way to handle multiple different IO operations as a
* single group. If any of the event emitters or callbacks registered to a
* domain emit an `'error'` event, or throw an error, then the domain object
* will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to
* exit immediately with an error code.
* @deprecated Since v1.4.2 - Deprecated
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/domain.js)
*/
declare module 'domain' {
import EventEmitter = require('events');
global {
namespace NodeJS {
interface Domain extends EventEmitter {
run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
add(emitter: EventEmitter | Timer): void;
remove(emitter: EventEmitter | Timer): void;
bind<T extends Function>(cb: T): T;
intercept<T extends Function>(cb: T): T;
}
}
}
interface Domain extends NodeJS.Domain {}
import EventEmitter = require('node:events');
/**
* The `Domain` class encapsulates the functionality of routing errors and
* uncaught exceptions to the active `Domain` object.
*
* To handle the errors that it catches, listen to its `'error'` event.
*/
class Domain extends EventEmitter {
/**
* An array of timers and event emitters that have been explicitly added
* to the domain.
*/
members: Array<EventEmitter | NodeJS.Timer>;
/**
* The `enter()` method is plumbing used by the `run()`, `bind()`, and`intercept()` methods to set the active domain. It sets `domain.active` and`process.domain` to the domain, and implicitly
* pushes the domain onto the domain
* stack managed by the domain module (see {@link exit} for details on the
* domain stack). The call to `enter()` delimits the beginning of a chain of
* asynchronous calls and I/O operations bound to a domain.
*
* Calling `enter()` changes only the active domain, and does not alter the domain
* itself. `enter()` and `exit()` can be called an arbitrary number of times on a
* single domain.
*/
enter(): void;
/**
* The `exit()` method exits the current domain, popping it off the domain stack.
* Any time execution is going to switch to the context of a different chain of
* asynchronous calls, it's important to ensure that the current domain is exited.
* The call to `exit()` delimits either the end of or an interruption to the chain
* of asynchronous calls and I/O operations bound to a domain.
*
* If there are multiple, nested domains bound to the current execution context,`exit()` will exit any domains nested within this domain.
*
* Calling `exit()` changes only the active domain, and does not alter the domain
* itself. `enter()` and `exit()` can be called an arbitrary number of times on a
* single domain.
*/
exit(): void;
/**
* Run the supplied function in the context of the domain, implicitly
* binding all event emitters, timers, and lowlevel requests that are
* created in that context. Optionally, arguments can be passed to
* the function.
*
* This is the most basic way to use a domain.
*
* ```js
* const domain = require('domain');
* const fs = require('fs');
* const d = domain.create();
* d.on('error', (er) => {
* console.error('Caught error!', er);
* });
* d.run(() => {
* process.nextTick(() => {
* setTimeout(() => { // Simulating some various async stuff
* fs.open('non-existent file', 'r', (er, fd) => {
* if (er) throw er;
* // proceed...
* });
* }, 100);
* });
* });
* ```
*
* In this example, the `d.on('error')` handler will be triggered, rather
* than crashing the program.
*/
run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
/**
* Explicitly adds an emitter to the domain. If any event handlers called by
* the emitter throw an error, or if the emitter emits an `'error'` event, it
* will be routed to the domain's `'error'` event, just like with implicit
* binding.
*
* This also works with timers that are returned from `setInterval()` and `setTimeout()`. If their callback function throws, it will be caught by
* the domain `'error'` handler.
*
* If the Timer or `EventEmitter` was already bound to a domain, it is removed
* from that one, and bound to this one instead.
* @param emitter emitter or timer to be added to the domain
*/
add(emitter: EventEmitter | NodeJS.Timer): void;
/**
* The opposite of {@link add}. Removes domain handling from the
* specified emitter.
* @param emitter emitter or timer to be removed from the domain
*/
remove(emitter: EventEmitter | NodeJS.Timer): void;
/**
* The returned function will be a wrapper around the supplied callback
* function. When the returned function is called, any errors that are
* thrown will be routed to the domain's `'error'` event.
*
* ```js
* const d = domain.create();
*
* function readSomeFile(filename, cb) {
* fs.readFile(filename, 'utf8', d.bind((er, data) => {
* // If this throws, it will also be passed to the domain.
* return cb(er, data ? JSON.parse(data) : null);
* }));
* }
*
* d.on('error', (er) => {
* // An error occurred somewhere. If we throw it now, it will crash the program
* // with the normal line number and stack message.
* });
* ```
* @param callback The callback function
* @return The bound function
*/
bind<T extends Function>(callback: T): T;
/**
* This method is almost identical to {@link bind}. However, in
* addition to catching thrown errors, it will also intercept `Error` objects sent as the first argument to the function.
*
* In this way, the common `if (err) return callback(err);` pattern can be replaced
* with a single error handler in a single place.
*
* ```js
* const d = domain.create();
*
* function readSomeFile(filename, cb) {
* fs.readFile(filename, 'utf8', d.intercept((data) => {
* // Note, the first argument is never passed to the
* // callback since it is assumed to be the 'Error' argument
* // and thus intercepted by the domain.
*
* // If this throws, it will also be passed to the domain
* // so the error-handling logic can be moved to the 'error'
* // event on the domain instead of being repeated throughout
* // the program.
* return cb(null, JSON.parse(data));
* }));
* }
*
* d.on('error', (er) => {
* // An error occurred somewhere. If we throw it now, it will crash the program
* // with the normal line number and stack message.
* });
* ```
* @param callback The callback function
* @return The intercepted function
*/
intercept<T extends Function>(callback: T): T;
}
function create(): Domain;
}
declare module 'node:domain' {

619
packages/node_modules/@node-red/editor-client/src/types/node/events.d.ts vendored
View File

@ -1,6 +1,42 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* Much of the Node.js core API is built around an idiomatic asynchronous
* event-driven architecture in which certain kinds of objects (called "emitters")
* emit named events that cause `Function` objects ("listeners") to be called.
*
* For instance: a `net.Server` object emits an event each time a peer
* connects to it; a `fs.ReadStream` emits an event when the file is opened;
* a `stream` emits an event whenever data is available to be read.
*
* All objects that emit events are instances of the `EventEmitter` class. These
* objects expose an `eventEmitter.on()` function that allows one or more
* functions to be attached to named events emitted by the object. Typically,
* event names are camel-cased strings but any valid JavaScript property key
* can be used.
*
* When the `EventEmitter` object emits an event, all of the functions attached
* to that specific event are called _synchronously_. Any values returned by the
* called listeners are _ignored_ and discarded.
*
* The following example shows a simple `EventEmitter` instance with a single
* listener. The `eventEmitter.on()` method is used to register listeners, while
* the `eventEmitter.emit()` method is used to trigger the event.
*
* ```js
* const EventEmitter = require('events');
*
* class MyEmitter extends EventEmitter {}
*
* const myEmitter = new MyEmitter();
* myEmitter.on('event', () => {
* console.log('an event occurred!');
* });
* myEmitter.emit('event');
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/events.js)
*/
declare module 'events' {
interface EventEmitterOptions {
/**
@ -8,26 +44,243 @@ declare module 'events' {
*/
captureRejections?: boolean | undefined;
}
interface NodeEventTarget {
once(event: string | symbol, listener: (...args: any[]) => void): this;
once(eventName: string | symbol, listener: (...args: any[]) => void): this;
}
interface DOMEventTarget {
addEventListener(event: string, listener: (...args: any[]) => void, opts?: { once: boolean }): any;
addEventListener(
eventName: string,
listener: (...args: any[]) => void,
opts?: {
once: boolean;
}
): any;
}
interface StaticEventEmitterOptions {
signal?: AbortSignal | undefined;
}
interface EventEmitter extends NodeJS.EventEmitter {}
/**
* The `EventEmitter` class is defined and exposed by the `events` module:
*
* ```js
* const EventEmitter = require('events');
* ```
*
* All `EventEmitter`s emit the event `'newListener'` when new listeners are
* added and `'removeListener'` when existing listeners are removed.
*
* It supports the following option:
* @since v0.1.26
*/
class EventEmitter {
constructor(options?: EventEmitterOptions);
static once(emitter: NodeEventTarget, event: string | symbol): Promise<any[]>;
static once(emitter: DOMEventTarget, event: string): Promise<any[]>;
static on(emitter: NodeJS.EventEmitter, event: string): AsyncIterableIterator<any>;
/** @deprecated since v4.0.0 */
static listenerCount(emitter: NodeJS.EventEmitter, event: string | symbol): number;
/**
* Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
* event or that is rejected if the `EventEmitter` emits `'error'` while waiting.
* The `Promise` will resolve with an array of all the arguments emitted to the
* given event.
*
* This method is intentionally generic and works with the web platform [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event
* semantics and does not listen to the `'error'` event.
*
* ```js
* const { once, EventEmitter } = require('events');
*
* async function run() {
* const ee = new EventEmitter();
*
* process.nextTick(() => {
* ee.emit('myevent', 42);
* });
*
* const [value] = await once(ee, 'myevent');
* console.log(value);
*
* const err = new Error('kaboom');
* process.nextTick(() => {
* ee.emit('error', err);
* });
*
* try {
* await once(ee, 'myevent');
* } catch (err) {
* console.log('error happened', err);
* }
* }
*
* run();
* ```
*
* The special handling of the `'error'` event is only used when `events.once()`is used to wait for another event. If `events.once()` is used to wait for the
* '`error'` event itself, then it is treated as any other kind of event without
* special handling:
*
* ```js
* const { EventEmitter, once } = require('events');
*
* const ee = new EventEmitter();
*
* once(ee, 'error')
* .then(([err]) => console.log('ok', err.message))
* .catch((err) => console.log('error', err.message));
*
* ee.emit('error', new Error('boom'));
*
* // Prints: ok boom
* ```
*
* An `AbortSignal` can be used to cancel waiting for the event:
*
* ```js
* const { EventEmitter, once } = require('events');
*
* const ee = new EventEmitter();
* const ac = new AbortController();
*
* async function foo(emitter, event, signal) {
* try {
* await once(emitter, event, { signal });
* console.log('event emitted!');
* } catch (error) {
* if (error.name === 'AbortError') {
* console.error('Waiting for the event was canceled!');
* } else {
* console.error('There was an error', error.message);
* }
* }
* }
*
* foo(ee, 'foo', ac.signal);
* ac.abort(); // Abort waiting for the event
* ee.emit('foo'); // Prints: Waiting for the event was canceled!
* ```
* @since v11.13.0, v10.16.0
*/
static once(emitter: NodeEventTarget, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>;
static once(emitter: DOMEventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
/**
* ```js
* const { on, EventEmitter } = require('events');
*
* (async () => {
* const ee = new EventEmitter();
*
* // Emit later on
* process.nextTick(() => {
* ee.emit('foo', 'bar');
* ee.emit('foo', 42);
* });
*
* for await (const event of on(ee, 'foo')) {
* // The execution of this inner block is synchronous and it
* // processes one event at a time (even with await). Do not use
* // if concurrent execution is required.
* console.log(event); // prints ['bar'] [42]
* }
* // Unreachable here
* })();
* ```
*
* Returns an `AsyncIterator` that iterates `eventName` events. It will throw
* if the `EventEmitter` emits `'error'`. It removes all listeners when
* exiting the loop. The `value` returned by each iteration is an array
* composed of the emitted event arguments.
*
* An `AbortSignal` can be used to cancel waiting on events:
*
* ```js
* const { on, EventEmitter } = require('events');
* const ac = new AbortController();
*
* (async () => {
* const ee = new EventEmitter();
*
* // Emit later on
* process.nextTick(() => {
* ee.emit('foo', 'bar');
* ee.emit('foo', 42);
* });
*
* for await (const event of on(ee, 'foo', { signal: ac.signal })) {
* // The execution of this inner block is synchronous and it
* // processes one event at a time (even with await). Do not use
* // if concurrent execution is required.
* console.log(event); // prints ['bar'] [42]
* }
* // Unreachable here
* })();
*
* process.nextTick(() => ac.abort());
* ```
* @since v13.6.0, v12.16.0
* @param eventName The name of the event being listened for
* @return that iterates `eventName` events emitted by the `emitter`
*/
static on(emitter: NodeJS.EventEmitter, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>;
/**
* A class method that returns the number of listeners for the given `eventName`registered on the given `emitter`.
*
* ```js
* const { EventEmitter, listenerCount } = require('events');
* const myEmitter = new EventEmitter();
* myEmitter.on('event', () => {});
* myEmitter.on('event', () => {});
* console.log(listenerCount(myEmitter, 'event'));
* // Prints: 2
* ```
* @since v0.9.12
* @deprecated Since v3.2.0 - Use `listenerCount` instead.
* @param emitter The emitter to query
* @param eventName The event name
*/
static listenerCount(emitter: NodeJS.EventEmitter, eventName: string | symbol): number;
/**
* Returns a copy of the array of listeners for the event named `eventName`.
*
* For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
* the emitter.
*
* For `EventTarget`s this is the only way to get the event listeners for the
* event target. This is useful for debugging and diagnostic purposes.
*
* ```js
* const { getEventListeners, EventEmitter } = require('events');
*
* {
* const ee = new EventEmitter();
* const listener = () => console.log('Events are fun');
* ee.on('foo', listener);
* getEventListeners(ee, 'foo'); // [listener]
* }
* {
* const et = new EventTarget();
* const listener = () => console.log('Events are fun');
* et.addEventListener('foo', listener);
* getEventListeners(et, 'foo'); // [listener]
* }
* ```
* @since v15.2.0
*/
static getEventListeners(emitter: DOMEventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
/**
* ```js
* const {
* setMaxListeners,
* EventEmitter
* } = require('events');
*
* const target = new EventTarget();
* const emitter = new EventEmitter();
*
* setMaxListeners(5, target, emitter);
* ```
* @since v15.4.0
* @param n A non-negative number. The maximum number of listeners per `EventTarget` event.
* @param eventsTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
* objects.
*/
static setMaxListeners(n?: number, ...eventTargets: Array<DOMEventTarget | NodeJS.EventEmitter>): void;
/**
* This symbol shall be used to install a listener for only monitoring `'error'`
* events. Listeners installed using this symbol are called before the regular
@ -39,7 +292,6 @@ declare module 'events' {
*/
static readonly errorMonitor: unique symbol;
static readonly captureRejectionSymbol: unique symbol;
/**
* Sets or gets the default captureRejection value for all emitters.
*/
@ -47,36 +299,343 @@ declare module 'events' {
static captureRejections: boolean;
static defaultMaxListeners: number;
}
import internal = require('events');
import internal = require('node:events');
namespace EventEmitter {
// Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
export { internal as EventEmitter };
export interface Abortable {
/**
* When provided the corresponding `AbortController` can be used to cancel an asynchronous action.
*/
signal?: AbortSignal | undefined;
}
}
global {
namespace NodeJS {
interface EventEmitter {
addListener(event: string | symbol, listener: (...args: any[]) => void): this;
on(event: string | symbol, listener: (...args: any[]) => void): this;
once(event: string | symbol, listener: (...args: any[]) => void): this;
removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
off(event: string | symbol, listener: (...args: any[]) => void): this;
/**
* Alias for `emitter.on(eventName, listener)`.
* @since v0.1.26
*/
addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
/**
* Adds the `listener` function to the end of the listeners array for the
* event named `eventName`. No checks are made to see if the `listener` has
* already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
* times.
*
* ```js
* server.on('connection', (stream) => {
* console.log('someone connected!');
* });
* ```
*
* Returns a reference to the `EventEmitter`, so that calls can be chained.
*
* By default, event listeners are invoked in the order they are added. The`emitter.prependListener()` method can be used as an alternative to add the
* event listener to the beginning of the listeners array.
*
* ```js
* const myEE = new EventEmitter();
* myEE.on('foo', () => console.log('a'));
* myEE.prependListener('foo', () => console.log('b'));
* myEE.emit('foo');
* // Prints:
* // b
* // a
* ```
* @since v0.1.101
* @param eventName The name of the event.
* @param listener The callback function
*/
on(eventName: string | symbol, listener: (...args: any[]) => void): this;
/**
* Adds a **one-time**`listener` function for the event named `eventName`. The
* next time `eventName` is triggered, this listener is removed and then invoked.
*
* ```js
* server.once('connection', (stream) => {
* console.log('Ah, we have our first user!');
* });
* ```
*
* Returns a reference to the `EventEmitter`, so that calls can be chained.
*
* By default, event listeners are invoked in the order they are added. The`emitter.prependOnceListener()` method can be used as an alternative to add the
* event listener to the beginning of the listeners array.
*
* ```js
* const myEE = new EventEmitter();
* myEE.once('foo', () => console.log('a'));
* myEE.prependOnceListener('foo', () => console.log('b'));
* myEE.emit('foo');
* // Prints:
* // b
* // a
* ```
* @since v0.3.0
* @param eventName The name of the event.
* @param listener The callback function
*/
once(eventName: string | symbol, listener: (...args: any[]) => void): this;
/**
* Removes the specified `listener` from the listener array for the event named`eventName`.
*
* ```js
* const callback = (stream) => {
* console.log('someone connected!');
* };
* server.on('connection', callback);
* // ...
* server.removeListener('connection', callback);
* ```
*
* `removeListener()` will remove, at most, one instance of a listener from the
* listener array. If any single listener has been added multiple times to the
* listener array for the specified `eventName`, then `removeListener()` must be
* called multiple times to remove each instance.
*
* Once an event is emitted, all listeners attached to it at the
* time of emitting are called in order. This implies that any`removeListener()` or `removeAllListeners()` calls _after_ emitting and_before_ the last listener finishes execution will
* not remove them from`emit()` in progress. Subsequent events behave as expected.
*
* ```js
* const myEmitter = new MyEmitter();
*
* const callbackA = () => {
* console.log('A');
* myEmitter.removeListener('event', callbackB);
* };
*
* const callbackB = () => {
* console.log('B');
* };
*
* myEmitter.on('event', callbackA);
*
* myEmitter.on('event', callbackB);
*
* // callbackA removes listener callbackB but it will still be called.
* // Internal listener array at time of emit [callbackA, callbackB]
* myEmitter.emit('event');
* // Prints:
* // A
* // B
*
* // callbackB is now removed.
* // Internal listener array [callbackA]
* myEmitter.emit('event');
* // Prints:
* // A
* ```
*
* Because listeners are managed using an internal array, calling this will
* change the position indices of any listener registered _after_ the listener
* being removed. This will not impact the order in which listeners are called,
* but it means that any copies of the listener array as returned by
* the `emitter.listeners()` method will need to be recreated.
*
* When a single function has been added as a handler multiple times for a single
* event (as in the example below), `removeListener()` will remove the most
* recently added instance. In the example the `once('ping')`listener is removed:
*
* ```js
* const ee = new EventEmitter();
*
* function pong() {
* console.log('pong');
* }
*
* ee.on('ping', pong);
* ee.once('ping', pong);
* ee.removeListener('ping', pong);
*
* ee.emit('ping');
* ee.emit('ping');
* ```
*
* Returns a reference to the `EventEmitter`, so that calls can be chained.
* @since v0.1.26
*/
removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
/**
* Alias for `emitter.removeListener()`.
* @since v10.0.0
*/
off(eventName: string | symbol, listener: (...args: any[]) => void): this;
/**
* Removes all listeners, or those of the specified `eventName`.
*
* It is bad practice to remove listeners added elsewhere in the code,
* particularly when the `EventEmitter` instance was created by some other
* component or module (e.g. sockets or file streams).
*
* Returns a reference to the `EventEmitter`, so that calls can be chained.
* @since v0.1.26
*/
removeAllListeners(event?: string | symbol): this;
/**
* By default `EventEmitter`s will print a warning if more than `10` listeners are
* added for a particular event. This is a useful default that helps finding
* memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
* modified for this specific `EventEmitter` instance. The value can be set to`Infinity` (or `0`) to indicate an unlimited number of listeners.
*
* Returns a reference to the `EventEmitter`, so that calls can be chained.
* @since v0.3.5
*/
setMaxListeners(n: number): this;
/**
* Returns the current max listener value for the `EventEmitter` which is either
* set by `emitter.setMaxListeners(n)` or defaults to {@link defaultMaxListeners}.
* @since v1.0.0
*/
getMaxListeners(): number;
listeners(event: string | symbol): Function[];
rawListeners(event: string | symbol): Function[];
emit(event: string | symbol, ...args: any[]): boolean;
listenerCount(event: string | symbol): number;
// Added in Node 6...
prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
/**
* Returns a copy of the array of listeners for the event named `eventName`.
*
* ```js
* server.on('connection', (stream) => {
* console.log('someone connected!');
* });
* console.log(util.inspect(server.listeners('connection')));
* // Prints: [ [Function] ]
* ```
* @since v0.1.26
*/
listeners(eventName: string | symbol): Function[];
/**
* Returns a copy of the array of listeners for the event named `eventName`,
* including any wrappers (such as those created by `.once()`).
*
* ```js
* const emitter = new EventEmitter();
* emitter.once('log', () => console.log('log once'));
*
* // Returns a new Array with a function `onceWrapper` which has a property
* // `listener` which contains the original listener bound above
* const listeners = emitter.rawListeners('log');
* const logFnWrapper = listeners[0];
*
* // Logs "log once" to the console and does not unbind the `once` event
* logFnWrapper.listener();
*
* // Logs "log once" to the console and removes the listener
* logFnWrapper();
*
* emitter.on('log', () => console.log('log persistently'));
* // Will return a new Array with a single function bound by `.on()` above
* const newListeners = emitter.rawListeners('log');
*
* // Logs "log persistently" twice
* newListeners[0]();
* emitter.emit('log');
* ```
* @since v9.4.0
*/
rawListeners(eventName: string | symbol): Function[];
/**
* Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments
* to each.
*
* Returns `true` if the event had listeners, `false` otherwise.
*
* ```js
* const EventEmitter = require('events');
* const myEmitter = new EventEmitter();
*
* // First listener
* myEmitter.on('event', function firstListener() {
* console.log('Helloooo! first listener');
* });
* // Second listener
* myEmitter.on('event', function secondListener(arg1, arg2) {
* console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
* });
* // Third listener
* myEmitter.on('event', function thirdListener(...args) {
* const parameters = args.join(', ');
* console.log(`event with parameters ${parameters} in third listener`);
* });
*
* console.log(myEmitter.listeners('event'));
*
* myEmitter.emit('event', 1, 2, 3, 4, 5);
*
* // Prints:
* // [
* // [Function: firstListener],
* // [Function: secondListener],
* // [Function: thirdListener]
* // ]
* // Helloooo! first listener
* // event with parameters 1, 2 in second listener
* // event with parameters 1, 2, 3, 4, 5 in third listener
* ```
* @since v0.1.26
*/
emit(eventName: string | symbol, ...args: any[]): boolean;
/**
* Returns the number of listeners listening to the event named `eventName`.
* @since v3.2.0
* @param eventName The name of the event being listened for
*/
listenerCount(eventName: string | symbol): number;
/**
* Adds the `listener` function to the _beginning_ of the listeners array for the
* event named `eventName`. No checks are made to see if the `listener` has
* already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
* times.
*
* ```js
* server.prependListener('connection', (stream) => {
* console.log('someone connected!');
* });
* ```
*
* Returns a reference to the `EventEmitter`, so that calls can be chained.
* @since v6.0.0
* @param eventName The name of the event.
* @param listener The callback function
*/
prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
/**
* Adds a **one-time**`listener` function for the event named `eventName` to the_beginning_ of the listeners array. The next time `eventName` is triggered, this
* listener is removed, and then invoked.
*
* ```js
* server.prependOnceListener('connection', (stream) => {
* console.log('Ah, we have our first user!');
* });
* ```
*
* Returns a reference to the `EventEmitter`, so that calls can be chained.
* @since v6.0.0
* @param eventName The name of the event.
* @param listener The callback function
*/
prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
/**
* Returns an array listing the events for which the emitter has registered
* listeners. The values in the array are strings or `Symbol`s.
*
* ```js
* const EventEmitter = require('events');
* const myEE = new EventEmitter();
* myEE.on('foo', () => {});
* myEE.on('bar', () => {});
*
* const sym = Symbol('symbol');
* myEE.on(sym, () => {});
*
* console.log(myEE.eventNames());
* // Prints: [ 'foo', 'bar', Symbol(symbol) ]
* ```
* @since v6.0.0
*/
eventNames(): Array<string | symbol>;
}
}
}
export = EventEmitter;
}
declare module 'node:events' {

3460
packages/node_modules/@node-red/editor-client/src/types/node/fs.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

1238
packages/node_modules/@node-red/editor-client/src/types/node/fs/promises.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

546
packages/node_modules/@node-red/editor-client/src/types/node/globals.d.ts vendored
View File

@ -16,23 +16,6 @@ interface ErrorConstructor {
stackTraceLimit: number;
}
// Node.js ESNEXT support
interface String {
/** Removes whitespace from the left end of a string. */
trimLeft(): string;
/** Removes whitespace from the right end of a string. */
trimRight(): string;
/** Returns a copy with leading whitespace removed. */
trimStart(): string;
/** Returns a copy with trailing whitespace removed. */
trimEnd(): string;
}
interface ImportMeta {
url: string;
}
/*-----------------------------------------------*
* *
* GLOBAL *
@ -40,9 +23,9 @@ interface ImportMeta {
------------------------------------------------*/
// For backwards compability
interface NodeRequire extends NodeJS.Require {}
interface RequireResolve extends NodeJS.RequireResolve {}
interface NodeModule extends NodeJS.Module {}
interface NodeRequire extends NodeJS.Require { }
interface RequireResolve extends NodeJS.RequireResolve { }
interface NodeModule extends NodeJS.Module { }
declare var process: NodeJS.Process;
declare var console: Console;
@ -50,61 +33,36 @@ declare var console: Console;
declare var __filename: string;
declare var __dirname: string;
declare function setTimeout(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
declare namespace setTimeout {
function __promisify__(ms: number): Promise<void>;
function __promisify__<T>(ms: number, value: T): Promise<T>;
}
declare function clearTimeout(timeoutId: NodeJS.Timeout): void;
declare function setInterval(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
declare function clearInterval(intervalId: NodeJS.Timeout): void;
declare function setImmediate(callback: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate;
declare namespace setImmediate {
function __promisify__(): Promise<void>;
function __promisify__<T>(value: T): Promise<T>;
}
declare function clearImmediate(immediateId: NodeJS.Immediate): void;
declare function queueMicrotask(callback: () => void): void;
declare var require: NodeRequire;
declare var module: NodeModule;
// Same as module.exports
declare var exports: any;
// Buffer class
type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
type WithImplicitCoercion<T> = T | { valueOf(): T };
/**
* Only available if `--expose-gc` is passed to the process.
*/
declare var gc: undefined | (() => void);
//#region borrowed
// from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
/**
* A controller object that allows you to abort one or more DOM requests as and when desired.
* @since v14.7.0
*/
/** A controller object that allows you to abort one or more DOM requests as and when desired. */
interface AbortController {
/**
* Returns the AbortSignal object associated with this object.
* @since v14.7.0
*/
readonly signal: AbortSignal;
/**
* Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
* @since v14.7.0
*/
abort(): void;
}
/**
* A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object.
* @since v14.7.0
*/
/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
interface AbortSignal {
/**
* Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
* @since v14.7.0
*/
readonly aborted: boolean;
}
@ -117,335 +75,35 @@ declare var AbortController: {
declare var AbortSignal: {
prototype: AbortSignal;
new(): AbortSignal;
// TODO: Add abort() static
abort(reason?: any): AbortSignal;
timeout(milliseconds: number): AbortSignal;
};
//#endregion borrowed
/**
* Raw data is stored in instances of the Buffer class.
* A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. A Buffer cannot be resized.
* Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'base64url'|'binary'(deprecated)|'hex'
*/
declare class Buffer extends Uint8Array {
//#region ArrayLike.at()
interface RelativeIndexable<T> {
/**
* Allocates a new buffer containing the given {str}.
*
* @param str String to store in buffer.
* @param encoding encoding to use, optional. Default is 'utf8'
* @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.
* Takes an integer value and returns the item at that index,
* allowing for positive and negative integers.
* Negative integers count back from the last item in the array.
*/
constructor(str: string, encoding?: BufferEncoding);
/**
* Allocates a new buffer of {size} octets.
*
* @param size count of octets to allocate.
* @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).
*/
constructor(size: number);
/**
* Allocates a new buffer containing the given {array} of octets.
*
* @param array The octets to store.
* @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
*/
constructor(array: Uint8Array);
/**
* Produces a Buffer backed by the same allocated memory as
* the given {ArrayBuffer}/{SharedArrayBuffer}.
*
*
* @param arrayBuffer The ArrayBuffer with which to share memory.
* @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
*/
constructor(arrayBuffer: ArrayBuffer | SharedArrayBuffer);
/**
* Allocates a new buffer containing the given {array} of octets.
*
* @param array The octets to store.
* @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
*/
constructor(array: ReadonlyArray<any>);
/**
* Copies the passed {buffer} data onto a new {Buffer} instance.
*
* @param buffer The buffer to copy.
* @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
*/
constructor(buffer: Buffer);
/**
* When passed a reference to the .buffer property of a TypedArray instance,
* the newly created Buffer will share the same allocated memory as the TypedArray.
* The optional {byteOffset} and {length} arguments specify a memory range
* within the {arrayBuffer} that will be shared by the Buffer.
*
* @param arrayBuffer The .buffer property of any TypedArray or a new ArrayBuffer()
*/
static from(arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>, byteOffset?: number, length?: number): Buffer;
/**
* Creates a new Buffer using the passed {data}
* @param data data to create a new Buffer
*/
static from(data: Uint8Array | ReadonlyArray<number>): Buffer;
static from(data: WithImplicitCoercion<Uint8Array | ReadonlyArray<number> | string>): Buffer;
/**
* Creates a new Buffer containing the given JavaScript string {str}.
* If provided, the {encoding} parameter identifies the character encoding.
* If not provided, {encoding} defaults to 'utf8'.
*/
static from(str: WithImplicitCoercion<string> | { [Symbol.toPrimitive](hint: 'string'): string }, encoding?: BufferEncoding): Buffer;
/**
* Creates a new Buffer using the passed {data}
* @param values to create a new Buffer
*/
static of(...items: number[]): Buffer;
/**
* Returns true if {obj} is a Buffer
*
* @param obj object to test.
*/
static isBuffer(obj: any): obj is Buffer;
/**
* Returns true if {encoding} is a valid encoding argument.
* Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'base64url'|'binary'(deprecated)|'hex'
*
* @param encoding string to test.
*/
static isEncoding(encoding: string): encoding is BufferEncoding;
/**
* Gives the actual byte length of a string. encoding defaults to 'utf8'.
* This is not the same as String.prototype.length since that returns the number of characters in a string.
*
* @param string string to test.
* @param encoding encoding used to evaluate (defaults to 'utf8')
*/
static byteLength(
string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
encoding?: BufferEncoding
): number;
/**
* Returns a buffer which is the result of concatenating all the buffers in the list together.
*
* If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
* If the list has exactly one item, then the first item of the list is returned.
* If the list has more than one item, then a new Buffer is created.
*
* @param list An array of Buffer objects to concatenate
* @param totalLength Total length of the buffers when concatenated.
* If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
*/
static concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer;
/**
* The same as buf1.compare(buf2).
*/
static compare(buf1: Uint8Array, buf2: Uint8Array): number;
/**
* Allocates a new buffer of {size} octets.
*
* @param size count of octets to allocate.
* @param fill if specified, buffer will be initialized by calling buf.fill(fill).
* If parameter is omitted, buffer will be filled with zeros.
* @param encoding encoding used for call to buf.fill while initalizing
*/
static alloc(size: number, fill?: string | Buffer | number, encoding?: BufferEncoding): Buffer;
/**
* Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
* of the newly created Buffer are unknown and may contain sensitive data.
*
* @param size count of octets to allocate
*/
static allocUnsafe(size: number): Buffer;
/**
* Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
* of the newly created Buffer are unknown and may contain sensitive data.
*
* @param size count of octets to allocate
*/
static allocUnsafeSlow(size: number): Buffer;
/**
* This is the number of bytes used to determine the size of pre-allocated, internal Buffer instances used for pooling. This value may be modified.
*/
static poolSize: number;
write(string: string, encoding?: BufferEncoding): number;
write(string: string, offset: number, encoding?: BufferEncoding): number;
write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
toString(encoding?: BufferEncoding, start?: number, end?: number): string;
toJSON(): { type: 'Buffer'; data: number[] };
equals(otherBuffer: Uint8Array): boolean;
compare(
otherBuffer: Uint8Array,
targetStart?: number,
targetEnd?: number,
sourceStart?: number,
sourceEnd?: number
): number;
copy(targetBuffer: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
/**
* Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
*
* This method is incompatible with `Uint8Array#slice()`, which returns a copy of the original memory.
*
* @param begin Where the new `Buffer` will start. Default: `0`.
* @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
*/
slice(begin?: number, end?: number): Buffer;
/**
* Returns a new `Buffer` that references **the same memory as the original**, but offset and cropped by the start and end indices.
*
* This method is compatible with `Uint8Array#subarray()`.
*
* @param begin Where the new `Buffer` will start. Default: `0`.
* @param end Where the new `Buffer` will end (not inclusive). Default: `buf.length`.
*/
subarray(begin?: number, end?: number): Buffer;
writeBigInt64BE(value: bigint, offset?: number): number;
writeBigInt64LE(value: bigint, offset?: number): number;
writeBigUInt64BE(value: bigint, offset?: number): number;
/**
* @alias Buffer.writeBigUInt64BE
* @since v14.10.0, v12.19.0
*/
writeBigUint64BE(value: bigint, offset?: number): number;
writeBigUInt64LE(value: bigint, offset?: number): number;
/**
* @alias Buffer.writeBigUInt64LE
* @since v14.10.0, v12.19.0
*/
writeBigUint64LE(value: bigint, offset?: number): number;
writeUIntLE(value: number, offset: number, byteLength: number): number;
/**
* @alias Buffer.writeUIntLE
* @since v14.9.0, v12.19.0
*/
writeUintLE(value: number, offset: number, byteLength: number): number;
writeUIntBE(value: number, offset: number, byteLength: number): number;
/**
* @alias Buffer.writeUIntBE
* @since v14.9.0, v12.19.0
*/
writeUintBE(value: number, offset: number, byteLength: number): number;
writeIntLE(value: number, offset: number, byteLength: number): number;
writeIntBE(value: number, offset: number, byteLength: number): number;
readBigUInt64BE(offset?: number): bigint;
/**
* @alias Buffer.readBigUInt64BE
* @since v14.10.0, v12.19.0
*/
readBigUint64BE(offset?: number): bigint;
readBigUInt64LE(offset?: number): bigint;
/**
* @alias Buffer.readBigUInt64LE
* @since v14.10.0, v12.19.0
*/
readBigUint64LE(offset?: number): bigint;
readBigInt64BE(offset?: number): bigint;
readBigInt64LE(offset?: number): bigint;
readUIntLE(offset: number, byteLength: number): number;
/**
* @alias Buffer.readUIntLE
* @since v14.9.0, v12.19.0
*/
readUintLE(offset: number, byteLength: number): number;
readUIntBE(offset: number, byteLength: number): number;
/**
* @alias Buffer.readUIntBE
* @since v14.9.0, v12.19.0
*/
readUintBE(offset: number, byteLength: number): number;
readIntLE(offset: number, byteLength: number): number;
readIntBE(offset: number, byteLength: number): number;
readUInt8(offset?: number): number;
/**
* @alias Buffer.readUInt8
* @since v14.9.0, v12.19.0
*/
readUint8(offset?: number): number;
readUInt16LE(offset?: number): number;
/**
* @alias Buffer.readUInt16LE
* @since v14.9.0, v12.19.0
*/
readUint16LE(offset?: number): number;
readUInt16BE(offset?: number): number;
/**
* @alias Buffer.readUInt16BE
* @since v14.9.0, v12.19.0
*/
readUint16BE(offset?: number): number;
readUInt32LE(offset?: number): number;
/**
* @alias Buffer.readUInt32LE
* @since v14.9.0, v12.19.0
*/
readUint32LE(offset?: number): number;
readUInt32BE(offset?: number): number;
/**
* @alias Buffer.readUInt32BE
* @since v14.9.0, v12.19.0
*/
readUint32BE(offset?: number): number;
readInt8(offset?: number): number;
readInt16LE(offset?: number): number;
readInt16BE(offset?: number): number;
readInt32LE(offset?: number): number;
readInt32BE(offset?: number): number;
readFloatLE(offset?: number): number;
readFloatBE(offset?: number): number;
readDoubleLE(offset?: number): number;
readDoubleBE(offset?: number): number;
reverse(): this;
swap16(): Buffer;
swap32(): Buffer;
swap64(): Buffer;
writeUInt8(value: number, offset?: number): number;
/**
* @alias Buffer.writeUInt8
* @since v14.9.0, v12.19.0
*/
writeUint8(value: number, offset?: number): number;
writeUInt16LE(value: number, offset?: number): number;
/**
* @alias Buffer.writeUInt16LE
* @since v14.9.0, v12.19.0
*/
writeUint16LE(value: number, offset?: number): number;
writeUInt16BE(value: number, offset?: number): number;
/**
* @alias Buffer.writeUInt16BE
* @since v14.9.0, v12.19.0
*/
writeUint16BE(value: number, offset?: number): number;
writeUInt32LE(value: number, offset?: number): number;
/**
* @alias Buffer.writeUInt32LE
* @since v14.9.0, v12.19.0
*/
writeUint32LE(value: number, offset?: number): number;
writeUInt32BE(value: number, offset?: number): number;
/**
* @alias Buffer.writeUInt32BE
* @since v14.9.0, v12.19.0
*/
writeUint32BE(value: number, offset?: number): number;
writeInt8(value: number, offset?: number): number;
writeInt16LE(value: number, offset?: number): number;
writeInt16BE(value: number, offset?: number): number;
writeInt32LE(value: number, offset?: number): number;
writeInt32BE(value: number, offset?: number): number;
writeFloatLE(value: number, offset?: number): number;
writeFloatBE(value: number, offset?: number): number;
writeDoubleLE(value: number, offset?: number): number;
writeDoubleBE(value: number, offset?: number): number;
fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
entries(): IterableIterator<[number, number]>;
includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
keys(): IterableIterator<number>;
values(): IterableIterator<number>;
at(index: number): T | undefined;
}
interface String extends RelativeIndexable<string> {}
interface Array<T> extends RelativeIndexable<T> {}
interface ReadonlyArray<T> extends RelativeIndexable<T> {}
interface Int8Array extends RelativeIndexable<number> {}
interface Uint8Array extends RelativeIndexable<number> {}
interface Uint8ClampedArray extends RelativeIndexable<number> {}
interface Int16Array extends RelativeIndexable<number> {}
interface Uint16Array extends RelativeIndexable<number> {}
interface Int32Array extends RelativeIndexable<number> {}
interface Uint32Array extends RelativeIndexable<number> {}
interface Float32Array extends RelativeIndexable<number> {}
interface Float64Array extends RelativeIndexable<number> {}
interface BigInt64Array extends RelativeIndexable<bigint> {}
interface BigUint64Array extends RelativeIndexable<bigint> {}
//#endregion ArrayLike.at() end
/*----------------------------------------------*
* *
@ -453,52 +111,11 @@ declare class Buffer extends Uint8Array {
* *
*-----------------------------------------------*/
declare namespace NodeJS {
interface InspectOptions {
/**
* If set to `true`, getters are going to be
* inspected as well. If set to `'get'` only getters without setter are going
* to be inspected. If set to `'set'` only getters having a corresponding
* setter are going to be inspected. This might cause side effects depending on
* the getter function.
* @default `false`
*/
getters?: 'get' | 'set' | boolean | undefined;
showHidden?: boolean | undefined;
/**
* @default 2
*/
depth?: number | null | undefined;
colors?: boolean | undefined;
customInspect?: boolean | undefined;
showProxy?: boolean | undefined;
maxArrayLength?: number | null | undefined;
/**
* Specifies the maximum number of characters to
* include when formatting. Set to `null` or `Infinity` to show all elements.
* Set to `0` or negative to show no characters.
* @default Infinity
*/
maxStringLength?: number | null | undefined;
breakLength?: number | undefined;
/**
* Setting this to `false` causes each object key
* to be displayed on a new line. It will also add new lines to text that is
* longer than `breakLength`. If set to a number, the most `n` inner elements
* are united on a single line as long as all properties fit into
* `breakLength`. Short array elements are also grouped together. Note that no
* text will be reduced below 16 characters, no matter the `breakLength` size.
* For more information, see the example below.
* @default `true`
*/
compact?: boolean | number | undefined;
sorted?: boolean | ((a: string, b: string) => number) | undefined;
}
interface CallSite {
/**
* Value of "this"
*/
getThis(): any;
getThis(): unknown;
/**
* Type of "this" as a string.
@ -593,99 +210,18 @@ declare namespace NodeJS {
writable: boolean;
write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
end(cb?: () => void): this;
end(data: string | Uint8Array, cb?: () => void): this;
end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
end(cb?: () => void): void;
end(data: string | Uint8Array, cb?: () => void): void;
end(str: string, encoding?: BufferEncoding, cb?: () => void): void;
}
interface ReadWriteStream extends ReadableStream, WritableStream { }
interface Global {
Array: typeof Array;
ArrayBuffer: typeof ArrayBuffer;
Boolean: typeof Boolean;
Buffer: typeof Buffer;
DataView: typeof DataView;
Date: typeof Date;
Error: typeof Error;
EvalError: typeof EvalError;
Float32Array: typeof Float32Array;
Float64Array: typeof Float64Array;
Function: typeof Function;
Infinity: typeof Infinity;
Int16Array: typeof Int16Array;
Int32Array: typeof Int32Array;
Int8Array: typeof Int8Array;
Intl: typeof Intl;
JSON: typeof JSON;
Map: MapConstructor;
Math: typeof Math;
NaN: typeof NaN;
Number: typeof Number;
Object: typeof Object;
Promise: typeof Promise;
RangeError: typeof RangeError;
ReferenceError: typeof ReferenceError;
RegExp: typeof RegExp;
Set: SetConstructor;
String: typeof String;
Symbol: Function;
SyntaxError: typeof SyntaxError;
TypeError: typeof TypeError;
URIError: typeof URIError;
Uint16Array: typeof Uint16Array;
Uint32Array: typeof Uint32Array;
Uint8Array: typeof Uint8Array;
Uint8ClampedArray: typeof Uint8ClampedArray;
WeakMap: WeakMapConstructor;
WeakSet: WeakSetConstructor;
clearImmediate: (immediateId: Immediate) => void;
clearInterval: (intervalId: Timeout) => void;
clearTimeout: (timeoutId: Timeout) => void;
decodeURI: typeof decodeURI;
decodeURIComponent: typeof decodeURIComponent;
encodeURI: typeof encodeURI;
encodeURIComponent: typeof encodeURIComponent;
escape: (str: string) => string;
eval: typeof eval;
global: Global;
isFinite: typeof isFinite;
isNaN: typeof isNaN;
parseFloat: typeof parseFloat;
parseInt: typeof parseInt;
setImmediate: (callback: (...args: any[]) => void, ...args: any[]) => Immediate;
setInterval: (callback: (...args: any[]) => void, ms?: number, ...args: any[]) => Timeout;
setTimeout: (callback: (...args: any[]) => void, ms?: number, ...args: any[]) => Timeout;
queueMicrotask: typeof queueMicrotask;
undefined: typeof undefined;
unescape: (str: string) => string;
gc: () => void;
v8debug?: any;
}
interface RefCounted {
ref(): this;
unref(): this;
}
// compatibility with older typings
interface Timer extends RefCounted {
hasRef(): boolean;
refresh(): this;
[Symbol.toPrimitive](): number;
}
interface Immediate extends RefCounted {
hasRef(): boolean;
_onImmediate: Function; // to distinguish it from the Timeout class
}
interface Timeout extends Timer {
hasRef(): boolean;
refresh(): this;
[Symbol.toPrimitive](): number;
}
type TypedArray =
| Uint8Array
| Uint8ClampedArray
@ -722,16 +258,20 @@ declare namespace NodeJS {
'.node': (m: Module, filename: string) => any;
}
interface Module {
/**
* `true` if the module is running during the Node.js preload
*/
isPreloading: boolean;
exports: any;
require: Require;
id: string;
filename: string;
loaded: boolean;
/** @deprecated since 14.6.0 Please use `require.main` and `module.children` instead. */
/** @deprecated since v14.6.0 Please use `require.main` and `module.children` instead. */
parent: Module | null | undefined;
children: Module[];
/**
* @since 11.14.0
* @since v11.14.0
*
* The directory name of the module. This is usually the same as the path.dirname() of the module.id.
*/

1301
packages/node_modules/@node-red/editor-client/src/types/node/http.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

2090
packages/node_modules/@node-red/editor-client/src/types/node/http2.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

534
packages/node_modules/@node-red/editor-client/src/types/node/https.d.ts vendored
View File

@ -1,54 +1,105 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
* separate module.
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/https.js)
*/
declare module 'https' {
import { Duplex } from 'stream';
import * as tls from 'tls';
import * as http from 'http';
import { URL } from 'url';
type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
type RequestOptions = http.RequestOptions & tls.SecureContextOptions & {
rejectUnauthorized?: boolean | undefined; // Defaults to true
servername?: string | undefined; // SNI TLS Extension
};
import { Duplex } from 'node:stream';
import * as tls from 'node:tls';
import * as http from 'node:http';
import { URL } from 'node:url';
type ServerOptions<
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
> = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
type RequestOptions = http.RequestOptions &
tls.SecureContextOptions & {
checkServerIdentity?: typeof tls.checkServerIdentity | undefined;
rejectUnauthorized?: boolean | undefined; // Defaults to true
servername?: string | undefined; // SNI TLS Extension
};
interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
rejectUnauthorized?: boolean | undefined;
maxCachedSessions?: number | undefined;
}
/**
* An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
* @since v0.4.5
*/
class Agent extends http.Agent {
constructor(options?: AgentOptions);
options: AgentOptions;
}
interface Server extends http.Server {}
class Server extends tls.Server {
constructor(requestListener?: http.RequestListener);
constructor(options: ServerOptions, requestListener?: http.RequestListener);
interface Server<
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
> extends http.Server<Request, Response> {}
/**
* See `http.Server` for more information.
* @since v0.3.4
*/
class Server<
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
> extends tls.Server {
constructor(requestListener?: http.RequestListener<Request, Response>);
constructor(
options: ServerOptions<Request, Response>,
requestListener?: http.RequestListener<Request, Response>,
);
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
addListener(
event: 'newSession',
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
): this;
addListener(
event: 'OCSPRequest',
listener: (
certificate: Buffer,
issuer: Buffer,
callback: (err: Error | null, resp: Buffer) => void,
) => void,
): this;
addListener(
event: 'resumeSession',
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
): this;
addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
addListener(event: 'close', listener: () => void): this;
addListener(event: 'connection', listener: (socket: Duplex) => void): this;
addListener(event: 'error', listener: (err: Error) => void): this;
addListener(event: 'listening', listener: () => void): this;
addListener(event: 'checkContinue', listener: http.RequestListener): this;
addListener(event: 'checkExpectation', listener: http.RequestListener): this;
addListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
addListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
addListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
addListener(event: 'request', listener: http.RequestListener): this;
addListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
addListener(
event: 'connect',
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
): this;
addListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
addListener(
event: 'upgrade',
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
): this;
emit(event: string, ...args: any[]): boolean;
emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
emit(
event: 'newSession',
sessionId: Buffer,
sessionData: Buffer,
callback: (err: Error, resp: Buffer) => void,
): boolean;
emit(
event: 'OCSPRequest',
certificate: Buffer,
issuer: Buffer,
callback: (err: Error | null, resp: Buffer) => void,
): boolean;
emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
@ -56,88 +107,427 @@ declare module 'https' {
emit(event: 'connection', socket: Duplex): boolean;
emit(event: 'error', err: Error): boolean;
emit(event: 'listening'): boolean;
emit(event: 'checkContinue', req: http.IncomingMessage, res: http.ServerResponse): boolean;
emit(event: 'checkExpectation', req: http.IncomingMessage, res: http.ServerResponse): boolean;
emit(
event: 'checkContinue',
req: InstanceType<Request>,
res: InstanceType<Response> & { req: InstanceType<Request> },
): boolean;
emit(
event: 'checkExpectation',
req: InstanceType<Request>,
res: InstanceType<Response> & { req: InstanceType<Request> },
): boolean;
emit(event: 'clientError', err: Error, socket: Duplex): boolean;
emit(event: 'connect', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
emit(event: 'request', req: http.IncomingMessage, res: http.ServerResponse): boolean;
emit(event: 'upgrade', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
emit(event: 'connect', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
emit(
event: 'request',
req: InstanceType<Request>,
res: InstanceType<Response> & { req: InstanceType<Request> },
): boolean;
emit(event: 'upgrade', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
on(
event: 'newSession',
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
): this;
on(
event: 'OCSPRequest',
listener: (
certificate: Buffer,
issuer: Buffer,
callback: (err: Error | null, resp: Buffer) => void,
) => void,
): this;
on(
event: 'resumeSession',
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
): this;
on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
on(event: 'close', listener: () => void): this;
on(event: 'connection', listener: (socket: Duplex) => void): this;
on(event: 'error', listener: (err: Error) => void): this;
on(event: 'listening', listener: () => void): this;
on(event: 'checkContinue', listener: http.RequestListener): this;
on(event: 'checkExpectation', listener: http.RequestListener): this;
on(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
on(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
on(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
on(event: 'request', listener: http.RequestListener): this;
on(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
on(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
on(event: 'request', listener: http.RequestListener<Request, Response>): this;
on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
once(
event: 'newSession',
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
): this;
once(
event: 'OCSPRequest',
listener: (
certificate: Buffer,
issuer: Buffer,
callback: (err: Error | null, resp: Buffer) => void,
) => void,
): this;
once(
event: 'resumeSession',
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
): this;
once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
once(event: 'close', listener: () => void): this;
once(event: 'connection', listener: (socket: Duplex) => void): this;
once(event: 'error', listener: (err: Error) => void): this;
once(event: 'listening', listener: () => void): this;
once(event: 'checkContinue', listener: http.RequestListener): this;
once(event: 'checkExpectation', listener: http.RequestListener): this;
once(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
once(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
once(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
once(event: 'request', listener: http.RequestListener): this;
once(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
once(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
once(event: 'request', listener: http.RequestListener<Request, Response>): this;
once(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
prependListener(
event: 'newSession',
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
): this;
prependListener(
event: 'OCSPRequest',
listener: (
certificate: Buffer,
issuer: Buffer,
callback: (err: Error | null, resp: Buffer) => void,
) => void,
): this;
prependListener(
event: 'resumeSession',
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
): this;
prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
prependListener(event: 'close', listener: () => void): this;
prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
prependListener(event: 'error', listener: (err: Error) => void): this;
prependListener(event: 'listening', listener: () => void): this;
prependListener(event: 'checkContinue', listener: http.RequestListener): this;
prependListener(event: 'checkExpectation', listener: http.RequestListener): this;
prependListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
prependListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
prependListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
prependListener(event: 'request', listener: http.RequestListener): this;
prependListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
prependListener(
event: 'connect',
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
): this;
prependListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
prependListener(
event: 'upgrade',
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
prependOnceListener(
event: 'newSession',
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
): this;
prependOnceListener(
event: 'OCSPRequest',
listener: (
certificate: Buffer,
issuer: Buffer,
callback: (err: Error | null, resp: Buffer) => void,
) => void,
): this;
prependOnceListener(
event: 'resumeSession',
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
): this;
prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
prependOnceListener(event: 'close', listener: () => void): this;
prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
prependOnceListener(event: 'listening', listener: () => void): this;
prependOnceListener(event: 'checkContinue', listener: http.RequestListener): this;
prependOnceListener(event: 'checkExpectation', listener: http.RequestListener): this;
prependOnceListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
prependOnceListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
prependOnceListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
prependOnceListener(event: 'request', listener: http.RequestListener): this;
prependOnceListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
prependOnceListener(
event: 'connect',
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
): this;
prependOnceListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
prependOnceListener(
event: 'upgrade',
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
): this;
}
function createServer(requestListener?: http.RequestListener): Server;
function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
/**
* ```js
* // curl -k https://localhost:8000/
* const https = require('https');
* const fs = require('fs');
*
* const options = {
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
* };
*
* https.createServer(options, (req, res) => {
* res.writeHead(200);
* res.end('hello world\n');
* }).listen(8000);
* ```
*
* Or
*
* ```js
* const https = require('https');
* const fs = require('fs');
*
* const options = {
* pfx: fs.readFileSync('test/fixtures/test_cert.pfx'),
* passphrase: 'sample'
* };
*
* https.createServer(options, (req, res) => {
* res.writeHead(200);
* res.end('hello world\n');
* }).listen(8000);
* ```
* @since v0.3.4
* @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
* @param requestListener A listener to be added to the `'request'` event.
*/
function createServer<
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
>(requestListener?: http.RequestListener<Request, Response>): Server<Request, Response>;
function createServer<
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
>(
options: ServerOptions<Request, Response>,
requestListener?: http.RequestListener<Request, Response>,
): Server<Request, Response>;
/**
* Makes a request to a secure web server.
*
* The following additional `options` from `tls.connect()` are also accepted:`ca`, `cert`, `ciphers`, `clientCertEngine`, `crl`, `dhparam`, `ecdhCurve`,`honorCipherOrder`, `key`, `passphrase`,
* `pfx`, `rejectUnauthorized`,`secureOptions`, `secureProtocol`, `servername`, `sessionIdContext`,`highWaterMark`.
*
* `options` can be an object, a string, or a `URL` object. If `options` is a
* string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
*
* `https.request()` returns an instance of the `http.ClientRequest` class. The `ClientRequest` instance is a writable stream. If one needs to
* upload a file with a POST request, then write to the `ClientRequest` object.
*
* ```js
* const https = require('https');
*
* const options = {
* hostname: 'encrypted.google.com',
* port: 443,
* path: '/',
* method: 'GET'
* };
*
* const req = https.request(options, (res) => {
* console.log('statusCode:', res.statusCode);
* console.log('headers:', res.headers);
*
* res.on('data', (d) => {
* process.stdout.write(d);
* });
* });
*
* req.on('error', (e) => {
* console.error(e);
* });
* req.end();
* ```
*
* Example using options from `tls.connect()`:
*
* ```js
* const options = {
* hostname: 'encrypted.google.com',
* port: 443,
* path: '/',
* method: 'GET',
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
* };
* options.agent = new https.Agent(options);
*
* const req = https.request(options, (res) => {
* // ...
* });
* ```
*
* Alternatively, opt out of connection pooling by not using an `Agent`.
*
* ```js
* const options = {
* hostname: 'encrypted.google.com',
* port: 443,
* path: '/',
* method: 'GET',
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
* agent: false
* };
*
* const req = https.request(options, (res) => {
* // ...
* });
* ```
*
* Example using a `URL` as `options`:
*
* ```js
* const options = new URL('https://abc:xyz@example.com');
*
* const req = https.request(options, (res) => {
* // ...
* });
* ```
*
* Example pinning on certificate fingerprint, or the public key (similar to`pin-sha256`):
*
* ```js
* const tls = require('tls');
* const https = require('https');
* const crypto = require('crypto');
*
* function sha256(s) {
* return crypto.createHash('sha256').update(s).digest('base64');
* }
* const options = {
* hostname: 'github.com',
* port: 443,
* path: '/',
* method: 'GET',
* checkServerIdentity: function(host, cert) {
* // Make sure the certificate is issued to the host we are connected to
* const err = tls.checkServerIdentity(host, cert);
* if (err) {
* return err;
* }
*
* // Pin the public key, similar to HPKP pin-sha25 pinning
* const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';
* if (sha256(cert.pubkey) !== pubkey256) {
* const msg = 'Certificate verification error: ' +
* `The public key of '${cert.subject.CN}' ` +
* 'does not match our pinned fingerprint';
* return new Error(msg);
* }
*
* // Pin the exact certificate, rather than the pub key
* const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +
* 'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';
* if (cert.fingerprint256 !== cert256) {
* const msg = 'Certificate verification error: ' +
* `The certificate of '${cert.subject.CN}' ` +
* 'does not match our pinned fingerprint';
* return new Error(msg);
* }
*
* // This loop is informational only.
* // Print the certificate and public key fingerprints of all certs in the
* // chain. Its common to pin the public key of the issuer on the public
* // internet, while pinning the public key of the service in sensitive
* // environments.
* do {
* console.log('Subject Common Name:', cert.subject.CN);
* console.log(' Certificate SHA256 fingerprint:', cert.fingerprint256);
*
* hash = crypto.createHash('sha256');
* console.log(' Public key ping-sha256:', sha256(cert.pubkey));
*
* lastprint256 = cert.fingerprint256;
* cert = cert.issuerCertificate;
* } while (cert.fingerprint256 !== lastprint256);
*
* },
* };
*
* options.agent = new https.Agent(options);
* const req = https.request(options, (res) => {
* console.log('All OK. Server matched our pinned cert or public key');
* console.log('statusCode:', res.statusCode);
* // Print the HPKP values
* console.log('headers:', res.headers['public-key-pins']);
*
* res.on('data', (d) => {});
* });
*
* req.on('error', (e) => {
* console.error(e.message);
* });
* req.end();
* ```
*
* Outputs for example:
*
* ```text
* Subject Common Name: github.com
* Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16
* Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=
* Subject Common Name: DigiCert SHA2 Extended Validation Server CA
* Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A
* Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=
* Subject Common Name: DigiCert High Assurance EV Root CA
* Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF
* Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=
* All OK. Server matched our pinned cert or public key
* statusCode: 200
* headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=";
* pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=";
* pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains
* ```
* @since v0.3.6
* @param options Accepts all `options` from `request`, with some differences in default values:
*/
function request(
options: RequestOptions | string | URL,
callback?: (res: http.IncomingMessage) => void,
): http.ClientRequest;
function request(
url: string | URL,
options: RequestOptions,
callback?: (res: http.IncomingMessage) => void,
): http.ClientRequest;
/**
* Like `http.get()` but for HTTPS.
*
* `options` can be an object, a string, or a `URL` object. If `options` is a
* string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
*
* ```js
* const https = require('https');
*
* https.get('https://encrypted.google.com/', (res) => {
* console.log('statusCode:', res.statusCode);
* console.log('headers:', res.headers);
*
* res.on('data', (d) => {
* process.stdout.write(d);
* });
*
* }).on('error', (e) => {
* console.error(e);
* });
* ```
* @since v0.3.6
* @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
*/
function get(
options: RequestOptions | string | URL,
callback?: (res: http.IncomingMessage) => void,
): http.ClientRequest;
function get(
url: string | URL,
options: RequestOptions,
callback?: (res: http.IncomingMessage) => void,
): http.ClientRequest;
let globalAgent: Agent;
}
declare module 'node:https' {

85
packages/node_modules/@node-red/editor-client/src/types/node/module.d.ts vendored
View File

@ -1,15 +1,53 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* @since v0.3.7
*/
declare module 'module' {
import { URL } from 'url';
import { URL } from 'node:url';
namespace Module {
/**
* Updates all the live bindings for builtin ES Modules to match the properties of the CommonJS exports.
* It does not add or remove exported names from the ES Modules.
* The `module.syncBuiltinESMExports()` method updates all the live bindings for
* builtin `ES Modules` to match the properties of the `CommonJS` exports. It
* does not add or remove exported names from the `ES Modules`.
*
* ```js
* const fs = require('fs');
* const assert = require('assert');
* const { syncBuiltinESMExports } = require('module');
*
* fs.readFile = newAPI;
*
* delete fs.readFileSync;
*
* function newAPI() {
* // ...
* }
*
* fs.newAPI = newAPI;
*
* syncBuiltinESMExports();
*
* import('fs').then((esmFS) => {
* // It syncs the existing readFile property with the new value
* assert.strictEqual(esmFS.readFile, newAPI);
* // readFileSync has been deleted from the required fs
* assert.strictEqual('readFileSync' in fs, false);
* // syncBuiltinESMExports() does not remove readFileSync from esmFS
* assert.strictEqual('readFileSync' in esmFS, true);
* // syncBuiltinESMExports() does not add names
* assert.strictEqual(esmFS.newAPI, undefined);
* });
* ```
* @since v12.12.0
*/
function syncBuiltinESMExports(): void;
/**
* `path` is the resolved path for the file for which a corresponding source map
* should be fetched.
* @since v13.7.0, v12.17.0
*/
function findSourceMap(path: string, error?: Error): SourceMap;
interface SourceMapPayload {
file: string;
@ -20,7 +58,6 @@ declare module 'module' {
mappings: string;
sourceRoot: string;
}
interface SourceMapping {
generatedLine: number;
generatedColumn: number;
@ -28,10 +65,20 @@ declare module 'module' {
originalLine: number;
originalColumn: number;
}
/**
* @since v13.7.0, v12.17.0
*/
class SourceMap {
/**
* Getter for the payload used to construct the `SourceMap` instance.
*/
readonly payload: SourceMapPayload;
constructor(payload: SourceMapPayload);
/**
* Given a line number and column number in the generated source file, returns
* an object representing the position in the original file. The object returned
* consists of the following keys:
*/
findEntry(line: number, column: number): SourceMapping;
}
}
@ -39,18 +86,30 @@ declare module 'module' {
class Module {
static runMain(): void;
static wrap(code: string): string;
/**
* @deprecated Deprecated since: v12.2.0. Please use createRequire() instead.
*/
static createRequireFromPath(path: string): NodeRequire;
static createRequire(path: string | URL): NodeRequire;
static builtinModules: string[];
static isBuiltin(moduleName: string): boolean;
static Module: typeof Module;
constructor(id: string, parent?: Module);
}
global {
interface ImportMeta {
url: string;
/**
* @experimental
* This feature is only available with the `--experimental-import-meta-resolve`
* command flag enabled.
*
* Provides a module-relative resolution function scoped to each module, returning
* the URL string.
*
* @param specified The module specifier to resolve relative to `parent`.
* @param parent The absolute parent module URL to resolve from. If none
* is specified, the value of `import.meta.url` is used as the default.
*/
resolve?(specified: string, parent?: string | URL): Promise<string>;
}
}
export = Module;
}
declare module 'node:module' {

794
packages/node_modules/@node-red/editor-client/src/types/node/net.d.ts vendored
View File

@ -1,30 +1,37 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* > Stability: 2 - Stable
*
* The `net` module provides an asynchronous network API for creating stream-based
* TCP or `IPC` servers ({@link createServer}) and clients
* ({@link createConnection}).
*
* It can be accessed using:
*
* ```js
* const net = require('net');
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/net.js)
*/
declare module 'net' {
import * as stream from 'stream';
import EventEmitter = require('events');
import * as dns from 'dns';
type LookupFunction = (
hostname: string,
options: dns.LookupOneOptions,
callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
) => void;
import * as stream from 'node:stream';
import { Abortable, EventEmitter } from 'node:events';
import * as dns from 'node:dns';
type LookupFunction = (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;
interface AddressInfo {
address: string;
family: string;
port: number;
}
interface SocketConstructorOpts {
fd?: number | undefined;
allowHalfOpen?: boolean | undefined;
readable?: boolean | undefined;
writable?: boolean | undefined;
signal?: AbortSignal;
}
interface OnReadOpts {
buffer: Uint8Array | (() => Uint8Array);
/**
@ -34,7 +41,6 @@ declare module 'net' {
*/
callback(bytesWritten: number, buf: Uint8Array): boolean;
}
interface ConnectOpts {
/**
* If specified, incoming data is stored in a single buffer and passed to the supplied callback when data arrives on the socket.
@ -43,7 +49,6 @@ declare module 'net' {
*/
onread?: OnReadOpts | undefined;
}
interface TcpSocketConnectOpts extends ConnectOpts {
port: number;
host?: string | undefined;
@ -52,53 +57,269 @@ declare module 'net' {
hints?: number | undefined;
family?: number | undefined;
lookup?: LookupFunction | undefined;
noDelay?: boolean | undefined;
keepAlive?: boolean | undefined;
keepAliveInitialDelay?: number | undefined;
}
interface IpcSocketConnectOpts extends ConnectOpts {
path: string;
}
type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;
type SocketReadyState = 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
/**
* This class is an abstraction of a TCP socket or a streaming `IPC` endpoint
* (uses named pipes on Windows, and Unix domain sockets otherwise). It is also
* an `EventEmitter`.
*
* A `net.Socket` can be created by the user and used directly to interact with
* a server. For example, it is returned by {@link createConnection},
* so the user can use it to talk to the server.
*
* It can also be created by Node.js and passed to the user when a connection
* is received. For example, it is passed to the listeners of a `'connection'` event emitted on a {@link Server}, so the user can use
* it to interact with the client.
* @since v0.3.4
*/
class Socket extends stream.Duplex {
constructor(options?: SocketConstructorOpts);
// Extended base methods
/**
* Sends data on the socket. The second parameter specifies the encoding in the
* case of a string. It defaults to UTF8 encoding.
*
* Returns `true` if the entire data was flushed successfully to the kernel
* buffer. Returns `false` if all or part of the data was queued in user memory.`'drain'` will be emitted when the buffer is again free.
*
* The optional `callback` parameter will be executed when the data is finally
* written out, which may not be immediately.
*
* See `Writable` stream `write()` method for more
* information.
* @since v0.1.90
* @param [encoding='utf8'] Only used when data is `string`.
*/
write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
/**
* Initiate a connection on a given socket.
*
* Possible signatures:
*
* * `socket.connect(options[, connectListener])`
* * `socket.connect(path[, connectListener])` for `IPC` connections.
* * `socket.connect(port[, host][, connectListener])` for TCP connections.
* * Returns: `net.Socket` The socket itself.
*
* This function is asynchronous. When the connection is established, the `'connect'` event will be emitted. If there is a problem connecting,
* instead of a `'connect'` event, an `'error'` event will be emitted with
* the error passed to the `'error'` listener.
* The last parameter `connectListener`, if supplied, will be added as a listener
* for the `'connect'` event **once**.
*
* This function should only be used for reconnecting a socket after`'close'` has been emitted or otherwise it may lead to undefined
* behavior.
*/
connect(options: SocketConnectOpts, connectionListener?: () => void): this;
connect(port: number, host: string, connectionListener?: () => void): this;
connect(port: number, connectionListener?: () => void): this;
connect(path: string, connectionListener?: () => void): this;
/**
* Set the encoding for the socket as a `Readable Stream`. See `readable.setEncoding()` for more information.
* @since v0.1.90
* @return The socket itself.
*/
setEncoding(encoding?: BufferEncoding): this;
/**
* Pauses the reading of data. That is, `'data'` events will not be emitted.
* Useful to throttle back an upload.
* @return The socket itself.
*/
pause(): this;
/**
* Resumes reading after a call to `socket.pause()`.
* @return The socket itself.
*/
resume(): this;
/**
* Sets the socket to timeout after `timeout` milliseconds of inactivity on
* the socket. By default `net.Socket` do not have a timeout.
*
* When an idle timeout is triggered the socket will receive a `'timeout'` event but the connection will not be severed. The user must manually call `socket.end()` or `socket.destroy()` to
* end the connection.
*
* ```js
* socket.setTimeout(3000);
* socket.on('timeout', () => {
* console.log('socket timeout');
* socket.end();
* });
* ```
*
* If `timeout` is 0, then the existing idle timeout is disabled.
*
* The optional `callback` parameter will be added as a one-time listener for the `'timeout'` event.
* @since v0.1.90
* @return The socket itself.
*/
setTimeout(timeout: number, callback?: () => void): this;
/**
* Enable/disable the use of Nagle's algorithm.
*
* When a TCP connection is created, it will have Nagle's algorithm enabled.
*
* Nagle's algorithm delays data before it is sent via the network. It attempts
* to optimize throughput at the expense of latency.
*
* Passing `true` for `noDelay` or not passing an argument will disable Nagle's
* algorithm for the socket. Passing `false` for `noDelay` will enable Nagle's
* algorithm.
* @since v0.1.90
* @param [noDelay=true]
* @return The socket itself.
*/
setNoDelay(noDelay?: boolean): this;
/**
* Enable/disable keep-alive functionality, and optionally set the initial
* delay before the first keepalive probe is sent on an idle socket.
*
* Set `initialDelay` (in milliseconds) to set the delay between the last
* data packet received and the first keepalive probe. Setting `0` for`initialDelay` will leave the value unchanged from the default
* (or previous) setting.
*
* Enabling the keep-alive functionality will set the following socket options:
*
* * `SO_KEEPALIVE=1`
* * `TCP_KEEPIDLE=initialDelay`
* * `TCP_KEEPCNT=10`
* * `TCP_KEEPINTVL=1`
* @since v0.1.92
* @param [enable=false]
* @param [initialDelay=0]
* @return The socket itself.
*/
setKeepAlive(enable?: boolean, initialDelay?: number): this;
/**
* Returns the bound `address`, the address `family` name and `port` of the
* socket as reported by the operating system:`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`
* @since v0.1.90
*/
address(): AddressInfo | {};
/**
* Calling `unref()` on a socket will allow the program to exit if this is the only
* active socket in the event system. If the socket is already `unref`ed calling`unref()` again will have no effect.
* @since v0.9.1
* @return The socket itself.
*/
unref(): this;
/**
* Opposite of `unref()`, calling `ref()` on a previously `unref`ed socket will_not_ let the program exit if it's the only socket left (the default behavior).
* If the socket is `ref`ed calling `ref` again will have no effect.
* @since v0.9.1
* @return The socket itself.
*/
ref(): this;
/** @deprecated since v14.6.0 - Use `writableLength` instead. */
/**
* This property shows the number of characters buffered for writing. The buffer
* may contain strings whose length after encoding is not yet known. So this number
* is only an approximation of the number of bytes in the buffer.
*
* `net.Socket` has the property that `socket.write()` always works. This is to
* help users get up and running quickly. The computer cannot always keep up
* with the amount of data that is written to a socket. The network connection
* simply might be too slow. Node.js will internally queue up the data written to a
* socket and send it out over the wire when it is possible.
*
* The consequence of this internal buffering is that memory may grow.
* Users who experience large or growing `bufferSize` should attempt to
* "throttle" the data flows in their program with `socket.pause()` and `socket.resume()`.
* @since v0.3.8
* @deprecated Since v14.6.0 - Use `writableLength` instead.
*/
readonly bufferSize: number;
/**
* The amount of received bytes.
* @since v0.5.3
*/
readonly bytesRead: number;
/**
* The amount of bytes sent.
* @since v0.5.3
*/
readonly bytesWritten: number;
/**
* If `true`,`socket.connect(options[, connectListener])` was
* called and has not yet finished. It will stay `true` until the socket becomes
* connected, then it is set to `false` and the `'connect'` event is emitted. Note
* that the `socket.connect(options[, connectListener])` callback is a listener for the `'connect'` event.
* @since v6.1.0
*/
readonly connecting: boolean;
/**
* See `writable.destroyed` for further details.
*/
readonly destroyed: boolean;
readonly localAddress: string;
readonly localPort: number;
/**
* The string representation of the local IP address the remote client is
* connecting on. For example, in a server listening on `'0.0.0.0'`, if a client
* connects on `'192.168.1.1'`, the value of `socket.localAddress` would be`'192.168.1.1'`.
* @since v0.9.6
*/
readonly localAddress?: string;
/**
* The numeric representation of the local port. For example, `80` or `21`.
* @since v0.9.6
*/
readonly localPort?: number;
/**
* The string representation of the local IP family. `'IPv4'` or `'IPv6'`.
* @since v18.8.0, v16.18.0
*/
readonly localFamily?: string;
/**
* This is `true` if the socket is not connected yet, either because `.connect()`
* has not yet been called or because it is still in the process of connecting (see `socket.connecting`).
* @since v10.16.0
*/
readonly pending: boolean;
/**
* This property represents the state of the connection as a string.
* @see {https://nodejs.org/api/net.html#socketreadystate}
* @since v0.5.0
*/
readonly readyState: SocketReadyState;
/**
* The string representation of the remote IP address. For example,`'74.125.127.100'` or `'2001:4860:a005::68'`. Value may be `undefined` if
* the socket is destroyed (for example, if the client disconnected).
* @since v0.5.10
*/
readonly remoteAddress?: string | undefined;
/**
* The string representation of the remote IP family. `'IPv4'` or `'IPv6'`.
* @since v0.11.14
*/
readonly remoteFamily?: string | undefined;
/**
* The numeric representation of the remote port. For example, `80` or `21`.
* @since v0.5.10
*/
readonly remotePort?: number | undefined;
// Extended base methods
end(cb?: () => void): this;
end(buffer: Uint8Array | string, cb?: () => void): this;
end(str: Uint8Array | string, encoding?: BufferEncoding, cb?: () => void): this;
/**
* The socket timeout in milliseconds as set by socket.setTimeout(). It is undefined if a timeout has not been set.
* @since v10.7.0
*/
readonly timeout?: number | undefined;
/**
* Half-closes the socket. i.e., it sends a FIN packet. It is possible the
* server will still send some data.
*
* See `writable.end()` for further details.
* @since v0.1.90
* @param [encoding='utf8'] Only used when data is `string`.
* @param callback Optional callback for when the socket is finished.
* @return The socket itself.
*/
end(callback?: () => void): this;
end(buffer: Uint8Array | string, callback?: () => void): this;
end(str: Uint8Array | string, encoding?: BufferEncoding, callback?: () => void): this;
/**
* events.EventEmitter
* 1. close
@ -111,73 +332,67 @@ declare module 'net' {
* 8. timeout
*/
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "close", listener: (had_error: boolean) => void): this;
addListener(event: "connect", listener: () => void): this;
addListener(event: "data", listener: (data: Buffer) => void): this;
addListener(event: "drain", listener: () => void): this;
addListener(event: "end", listener: () => void): this;
addListener(event: "error", listener: (err: Error) => void): this;
addListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
addListener(event: "ready", listener: () => void): this;
addListener(event: "timeout", listener: () => void): this;
addListener(event: 'close', listener: (hadError: boolean) => void): this;
addListener(event: 'connect', listener: () => void): this;
addListener(event: 'data', listener: (data: Buffer) => void): this;
addListener(event: 'drain', listener: () => void): this;
addListener(event: 'end', listener: () => void): this;
addListener(event: 'error', listener: (err: Error) => void): this;
addListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
addListener(event: 'ready', listener: () => void): this;
addListener(event: 'timeout', listener: () => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "close", had_error: boolean): boolean;
emit(event: "connect"): boolean;
emit(event: "data", data: Buffer): boolean;
emit(event: "drain"): boolean;
emit(event: "end"): boolean;
emit(event: "error", err: Error): boolean;
emit(event: "lookup", err: Error, address: string, family: string | number, host: string): boolean;
emit(event: "ready"): boolean;
emit(event: "timeout"): boolean;
emit(event: 'close', hadError: boolean): boolean;
emit(event: 'connect'): boolean;
emit(event: 'data', data: Buffer): boolean;
emit(event: 'drain'): boolean;
emit(event: 'end'): boolean;
emit(event: 'error', err: Error): boolean;
emit(event: 'lookup', err: Error, address: string, family: string | number, host: string): boolean;
emit(event: 'ready'): boolean;
emit(event: 'timeout'): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "close", listener: (had_error: boolean) => void): this;
on(event: "connect", listener: () => void): this;
on(event: "data", listener: (data: Buffer) => void): this;
on(event: "drain", listener: () => void): this;
on(event: "end", listener: () => void): this;
on(event: "error", listener: (err: Error) => void): this;
on(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
on(event: "ready", listener: () => void): this;
on(event: "timeout", listener: () => void): this;
on(event: 'close', listener: (hadError: boolean) => void): this;
on(event: 'connect', listener: () => void): this;
on(event: 'data', listener: (data: Buffer) => void): this;
on(event: 'drain', listener: () => void): this;
on(event: 'end', listener: () => void): this;
on(event: 'error', listener: (err: Error) => void): this;
on(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
on(event: 'ready', listener: () => void): this;
on(event: 'timeout', listener: () => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "close", listener: (had_error: boolean) => void): this;
once(event: "connect", listener: () => void): this;
once(event: "data", listener: (data: Buffer) => void): this;
once(event: "drain", listener: () => void): this;
once(event: "end", listener: () => void): this;
once(event: "error", listener: (err: Error) => void): this;
once(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
once(event: "ready", listener: () => void): this;
once(event: "timeout", listener: () => void): this;
once(event: 'close', listener: (hadError: boolean) => void): this;
once(event: 'connect', listener: () => void): this;
once(event: 'data', listener: (data: Buffer) => void): this;
once(event: 'drain', listener: () => void): this;
once(event: 'end', listener: () => void): this;
once(event: 'error', listener: (err: Error) => void): this;
once(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
once(event: 'ready', listener: () => void): this;
once(event: 'timeout', listener: () => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "close", listener: (had_error: boolean) => void): this;
prependListener(event: "connect", listener: () => void): this;
prependListener(event: "data", listener: (data: Buffer) => void): this;
prependListener(event: "drain", listener: () => void): this;
prependListener(event: "end", listener: () => void): this;
prependListener(event: "error", listener: (err: Error) => void): this;
prependListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
prependListener(event: "ready", listener: () => void): this;
prependListener(event: "timeout", listener: () => void): this;
prependListener(event: 'close', listener: (hadError: boolean) => void): this;
prependListener(event: 'connect', listener: () => void): this;
prependListener(event: 'data', listener: (data: Buffer) => void): this;
prependListener(event: 'drain', listener: () => void): this;
prependListener(event: 'end', listener: () => void): this;
prependListener(event: 'error', listener: (err: Error) => void): this;
prependListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
prependListener(event: 'ready', listener: () => void): this;
prependListener(event: 'timeout', listener: () => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "close", listener: (had_error: boolean) => void): this;
prependOnceListener(event: "connect", listener: () => void): this;
prependOnceListener(event: "data", listener: (data: Buffer) => void): this;
prependOnceListener(event: "drain", listener: () => void): this;
prependOnceListener(event: "end", listener: () => void): this;
prependOnceListener(event: "error", listener: (err: Error) => void): this;
prependOnceListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
prependOnceListener(event: "ready", listener: () => void): this;
prependOnceListener(event: "timeout", listener: () => void): this;
prependOnceListener(event: 'close', listener: (hadError: boolean) => void): this;
prependOnceListener(event: 'connect', listener: () => void): this;
prependOnceListener(event: 'data', listener: (data: Buffer) => void): this;
prependOnceListener(event: 'drain', listener: () => void): this;
prependOnceListener(event: 'end', listener: () => void): this;
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
prependOnceListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
prependOnceListener(event: 'ready', listener: () => void): this;
prependOnceListener(event: 'timeout', listener: () => void): this;
}
interface ListenOptions {
interface ListenOptions extends Abortable {
port?: number | undefined;
host?: string | undefined;
backlog?: number | undefined;
@ -190,26 +405,85 @@ declare module 'net' {
*/
ipv6Only?: boolean | undefined;
}
interface ServerOpts {
/**
* Indicates whether half-opened TCP connections are allowed.
* @default false
*/
allowHalfOpen?: boolean | undefined;
/**
* Indicates whether the socket should be paused on incoming connections.
* @default false
*/
pauseOnConnect?: boolean | undefined;
/**
* If set to `true`, it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
* @default false
* @since v16.5.0
*/
noDelay?: boolean | undefined;
/**
* If set to `true`, it enables keep-alive functionality on the socket immediately after a new incoming connection is received,
* similarly on what is done in `socket.setKeepAlive([enable][, initialDelay])`.
* @default false
* @since v16.5.0
*/
keepAlive?: boolean | undefined;
/**
* If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
* @default 0
* @since v16.5.0
*/
keepAliveInitialDelay?: number | undefined;
}
// https://github.com/nodejs/node/blob/master/lib/net.js
/**
* This class is used to create a TCP or `IPC` server.
* @since v0.1.90
*/
class Server extends EventEmitter {
constructor(connectionListener?: (socket: Socket) => void);
constructor(options?: ServerOpts, connectionListener?: (socket: Socket) => void);
/**
* Start a server listening for connections. A `net.Server` can be a TCP or
* an `IPC` server depending on what it listens to.
*
* Possible signatures:
*
* * `server.listen(handle[, backlog][, callback])`
* * `server.listen(options[, callback])`
* * `server.listen(path[, backlog][, callback])` for `IPC` servers
* * `server.listen([port[, host[, backlog]]][, callback])` for TCP servers
*
* This function is asynchronous. When the server starts listening, the `'listening'` event will be emitted. The last parameter `callback`will be added as a listener for the `'listening'`
* event.
*
* All `listen()` methods can take a `backlog` parameter to specify the maximum
* length of the queue of pending connections. The actual length will be determined
* by the OS through sysctl settings such as `tcp_max_syn_backlog` and `somaxconn`on Linux. The default value of this parameter is 511 (not 512).
*
* All {@link Socket} are set to `SO_REUSEADDR` (see [`socket(7)`](https://man7.org/linux/man-pages/man7/socket.7.html) for
* details).
*
* The `server.listen()` method can be called again if and only if there was an
* error during the first `server.listen()` call or `server.close()` has been
* called. Otherwise, an `ERR_SERVER_ALREADY_LISTEN` error will be thrown.
*
* One of the most common errors raised when listening is `EADDRINUSE`.
* This happens when another server is already listening on the requested`port`/`path`/`handle`. One way to handle this would be to retry
* after a certain amount of time:
*
* ```js
* server.on('error', (e) => {
* if (e.code === 'EADDRINUSE') {
* console.log('Address in use, retrying...');
* setTimeout(() => {
* server.close();
* server.listen(PORT, HOST);
* }, 1000);
* }
* });
* ```
*/
listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
listen(port?: number, hostname?: string, listeningListener?: () => void): this;
listen(port?: number, backlog?: number, listeningListener?: () => void): this;
@ -219,15 +493,79 @@ declare module 'net' {
listen(options: ListenOptions, listeningListener?: () => void): this;
listen(handle: any, backlog?: number, listeningListener?: () => void): this;
listen(handle: any, listeningListener?: () => void): this;
/**
* Stops the server from accepting new connections and keeps existing
* connections. This function is asynchronous, the server is finally closed
* when all connections are ended and the server emits a `'close'` event.
* The optional `callback` will be called once the `'close'` event occurs. Unlike
* that event, it will be called with an `Error` as its only argument if the server
* was not open when it was closed.
* @since v0.1.90
* @param callback Called when the server is closed.
*/
close(callback?: (err?: Error) => void): this;
/**
* Returns the bound `address`, the address `family` name, and `port` of the server
* as reported by the operating system if listening on an IP socket
* (useful to find which port was assigned when getting an OS-assigned address):`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`.
*
* For a server listening on a pipe or Unix domain socket, the name is returned
* as a string.
*
* ```js
* const server = net.createServer((socket) => {
* socket.end('goodbye\n');
* }).on('error', (err) => {
* // Handle errors here.
* throw err;
* });
*
* // Grab an arbitrary unused port.
* server.listen(() => {
* console.log('opened server on', server.address());
* });
* ```
*
* `server.address()` returns `null` before the `'listening'` event has been
* emitted or after calling `server.close()`.
* @since v0.1.90
*/
address(): AddressInfo | string | null;
/**
* Asynchronously get the number of concurrent connections on the server. Works
* when sockets were sent to forks.
*
* Callback should take two arguments `err` and `count`.
* @since v0.9.7
*/
getConnections(cb: (error: Error | null, count: number) => void): void;
/**
* Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will_not_ let the program exit if it's the only server left (the default behavior).
* If the server is `ref`ed calling `ref()` again will have no effect.
* @since v0.9.1
*/
ref(): this;
/**
* Calling `unref()` on a server will allow the program to exit if this is the only
* active server in the event system. If the server is already `unref`ed calling`unref()` again will have no effect.
* @since v0.9.1
*/
unref(): this;
/**
* Set this property to reject connections when the server's connection count gets
* high.
*
* It is not recommended to use this option once a socket has been sent to a child
* with `child_process.fork()`.
* @since v0.2.0
*/
maxConnections: number;
connections: number;
/**
* Indicates whether or not the server is listening for connections.
* @since v5.7.0
*/
listening: boolean;
/**
* events.EventEmitter
* 1. close
@ -236,63 +574,257 @@ declare module 'net' {
* 4. listening
*/
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "close", listener: () => void): this;
addListener(event: "connection", listener: (socket: Socket) => void): this;
addListener(event: "error", listener: (err: Error) => void): this;
addListener(event: "listening", listener: () => void): this;
addListener(event: 'close', listener: () => void): this;
addListener(event: 'connection', listener: (socket: Socket) => void): this;
addListener(event: 'error', listener: (err: Error) => void): this;
addListener(event: 'listening', listener: () => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "close"): boolean;
emit(event: "connection", socket: Socket): boolean;
emit(event: "error", err: Error): boolean;
emit(event: "listening"): boolean;
emit(event: 'close'): boolean;
emit(event: 'connection', socket: Socket): boolean;
emit(event: 'error', err: Error): boolean;
emit(event: 'listening'): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "close", listener: () => void): this;
on(event: "connection", listener: (socket: Socket) => void): this;
on(event: "error", listener: (err: Error) => void): this;
on(event: "listening", listener: () => void): this;
on(event: 'close', listener: () => void): this;
on(event: 'connection', listener: (socket: Socket) => void): this;
on(event: 'error', listener: (err: Error) => void): this;
on(event: 'listening', listener: () => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "close", listener: () => void): this;
once(event: "connection", listener: (socket: Socket) => void): this;
once(event: "error", listener: (err: Error) => void): this;
once(event: "listening", listener: () => void): this;
once(event: 'close', listener: () => void): this;
once(event: 'connection', listener: (socket: Socket) => void): this;
once(event: 'error', listener: (err: Error) => void): this;
once(event: 'listening', listener: () => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "close", listener: () => void): this;
prependListener(event: "connection", listener: (socket: Socket) => void): this;
prependListener(event: "error", listener: (err: Error) => void): this;
prependListener(event: "listening", listener: () => void): this;
prependListener(event: 'close', listener: () => void): this;
prependListener(event: 'connection', listener: (socket: Socket) => void): this;
prependListener(event: 'error', listener: (err: Error) => void): this;
prependListener(event: 'listening', listener: () => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "close", listener: () => void): this;
prependOnceListener(event: "connection", listener: (socket: Socket) => void): this;
prependOnceListener(event: "error", listener: (err: Error) => void): this;
prependOnceListener(event: "listening", listener: () => void): this;
prependOnceListener(event: 'close', listener: () => void): this;
prependOnceListener(event: 'connection', listener: (socket: Socket) => void): this;
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
prependOnceListener(event: 'listening', listener: () => void): this;
}
type IPVersion = 'ipv4' | 'ipv6';
/**
* The `BlockList` object can be used with some network APIs to specify rules for
* disabling inbound or outbound access to specific IP addresses, IP ranges, or
* IP subnets.
* @since v15.0.0
*/
class BlockList {
/**
* Adds a rule to block the given IP address.
* @since v15.0.0
* @param address An IPv4 or IPv6 address.
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
*/
addAddress(address: string, type?: IPVersion): void;
addAddress(address: SocketAddress): void;
/**
* Adds a rule to block a range of IP addresses from `start` (inclusive) to`end` (inclusive).
* @since v15.0.0
* @param start The starting IPv4 or IPv6 address in the range.
* @param end The ending IPv4 or IPv6 address in the range.
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
*/
addRange(start: string, end: string, type?: IPVersion): void;
addRange(start: SocketAddress, end: SocketAddress): void;
/**
* Adds a rule to block a range of IP addresses specified as a subnet mask.
* @since v15.0.0
* @param net The network IPv4 or IPv6 address.
* @param prefix The number of CIDR prefix bits. For IPv4, this must be a value between `0` and `32`. For IPv6, this must be between `0` and `128`.
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
*/
addSubnet(net: SocketAddress, prefix: number): void;
addSubnet(net: string, prefix: number, type?: IPVersion): void;
/**
* Returns `true` if the given IP address matches any of the rules added to the`BlockList`.
*
* ```js
* const blockList = new net.BlockList();
* blockList.addAddress('123.123.123.123');
* blockList.addRange('10.0.0.1', '10.0.0.10');
* blockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');
*
* console.log(blockList.check('123.123.123.123')); // Prints: true
* console.log(blockList.check('10.0.0.3')); // Prints: true
* console.log(blockList.check('222.111.111.222')); // Prints: false
*
* // IPv6 notation for IPv4 addresses works:
* console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true
* console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true
* ```
* @since v15.0.0
* @param address The IP address to check
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
*/
check(address: SocketAddress): boolean;
check(address: string, type?: IPVersion): boolean;
}
interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
timeout?: number | undefined;
}
interface IpcNetConnectOpts extends IpcSocketConnectOpts, SocketConstructorOpts {
timeout?: number | undefined;
}
type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts;
/**
* Creates a new TCP or `IPC` server.
*
* If `allowHalfOpen` is set to `true`, when the other end of the socket
* signals the end of transmission, the server will only send back the end of
* transmission when `socket.end()` is explicitly called. For example, in the
* context of TCP, when a FIN packed is received, a FIN packed is sent
* back only when `socket.end()` is explicitly called. Until then the
* connection is half-closed (non-readable but still writable). See `'end'` event and [RFC 1122](https://tools.ietf.org/html/rfc1122) (section 4.2.2.13) for more information.
*
* If `pauseOnConnect` is set to `true`, then the socket associated with each
* incoming connection will be paused, and no data will be read from its handle.
* This allows connections to be passed between processes without any data being
* read by the original process. To begin reading data from a paused socket, call `socket.resume()`.
*
* The server can be a TCP server or an `IPC` server, depending on what it `listen()` to.
*
* Here is an example of an TCP echo server which listens for connections
* on port 8124:
*
* ```js
* const net = require('net');
* const server = net.createServer((c) => {
* // 'connection' listener.
* console.log('client connected');
* c.on('end', () => {
* console.log('client disconnected');
* });
* c.write('hello\r\n');
* c.pipe(c);
* });
* server.on('error', (err) => {
* throw err;
* });
* server.listen(8124, () => {
* console.log('server bound');
* });
* ```
*
* Test this by using `telnet`:
*
* ```console
* $ telnet localhost 8124
* ```
*
* To listen on the socket `/tmp/echo.sock`:
*
* ```js
* server.listen('/tmp/echo.sock', () => {
* console.log('server bound');
* });
* ```
*
* Use `nc` to connect to a Unix domain socket server:
*
* ```console
* $ nc -U /tmp/echo.sock
* ```
* @since v0.5.0
* @param connectionListener Automatically set as a listener for the {@link 'connection'} event.
*/
function createServer(connectionListener?: (socket: Socket) => void): Server;
function createServer(options?: ServerOpts, connectionListener?: (socket: Socket) => void): Server;
/**
* Aliases to {@link createConnection}.
*
* Possible signatures:
*
* * {@link connect}
* * {@link connect} for `IPC` connections.
* * {@link connect} for TCP connections.
*/
function connect(options: NetConnectOpts, connectionListener?: () => void): Socket;
function connect(port: number, host?: string, connectionListener?: () => void): Socket;
function connect(path: string, connectionListener?: () => void): Socket;
/**
* A factory function, which creates a new {@link Socket},
* immediately initiates connection with `socket.connect()`,
* then returns the `net.Socket` that starts the connection.
*
* When the connection is established, a `'connect'` event will be emitted
* on the returned socket. The last parameter `connectListener`, if supplied,
* will be added as a listener for the `'connect'` event **once**.
*
* Possible signatures:
*
* * {@link createConnection}
* * {@link createConnection} for `IPC` connections.
* * {@link createConnection} for TCP connections.
*
* The {@link connect} function is an alias to this function.
*/
function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;
function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
function createConnection(path: string, connectionListener?: () => void): Socket;
/**
* Tests if input is an IP address. Returns `0` for invalid strings,
* returns `4` for IP version 4 addresses, and returns `6` for IP version 6
* addresses.
* @since v0.3.0
*/
function isIP(input: string): number;
/**
* Returns `true` if input is a version 4 IP address, otherwise returns `false`.
* @since v0.3.0
*/
function isIPv4(input: string): boolean;
/**
* Returns `true` if input is a version 6 IP address, otherwise returns `false`.
* @since v0.3.0
*/
function isIPv6(input: string): boolean;
interface SocketAddressInitOptions {
/**
* The network address as either an IPv4 or IPv6 string.
* @default 127.0.0.1
*/
address?: string | undefined;
/**
* @default `'ipv4'`
*/
family?: IPVersion | undefined;
/**
* An IPv6 flow-label used only if `family` is `'ipv6'`.
* @default 0
*/
flowlabel?: number | undefined;
/**
* An IP port.
* @default 0
*/
port?: number | undefined;
}
/**
* @since v15.14.0
*/
class SocketAddress {
constructor(options: SocketAddressInitOptions);
/**
* @since v15.14.0
*/
readonly address: string;
/**
* Either \`'ipv4'\` or \`'ipv6'\`.
* @since v15.14.0
*/
readonly family: IPVersion;
/**
* @since v15.14.0
*/
readonly port: number;
/**
* @since v15.14.0
*/
readonly flowlabel: number;
}
}
declare module 'node:net' {
export * from 'net';

267
packages/node_modules/@node-red/editor-client/src/types/node/os.d.ts vendored
View File

@ -1,6 +1,15 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `os` module provides operating system-related utility methods and
* properties. It can be accessed using:
*
* ```js
* const os = require('os');
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/os.js)
*/
declare module 'os' {
interface CpuInfo {
model: string;
@ -13,7 +22,6 @@ declare module 'os' {
irq: number;
};
}
interface NetworkInterfaceBase {
address: string;
netmask: string;
@ -21,16 +29,13 @@ declare module 'os' {
internal: boolean;
cidr: string | null;
}
interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
family: "IPv4";
family: 'IPv4';
}
interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
family: "IPv6";
family: 'IPv6';
scopeid: number;
}
interface UserInfo<T> {
username: T;
uid: number;
@ -38,26 +43,197 @@ declare module 'os' {
shell: T;
homedir: T;
}
type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
/**
* Returns the host name of the operating system as a string.
* @since v0.3.3
*/
function hostname(): string;
/**
* Returns an array containing the 1, 5, and 15 minute load averages.
*
* The load average is a measure of system activity calculated by the operating
* system and expressed as a fractional number.
*
* The load average is a Unix-specific concept. On Windows, the return value is
* always `[0, 0, 0]`.
* @since v0.3.3
*/
function loadavg(): number[];
/**
* Returns the system uptime in number of seconds.
* @since v0.3.3
*/
function uptime(): number;
/**
* Returns the amount of free system memory in bytes as an integer.
* @since v0.3.3
*/
function freemem(): number;
/**
* Returns the total amount of system memory in bytes as an integer.
* @since v0.3.3
*/
function totalmem(): number;
/**
* Returns an array of objects containing information about each logical CPU core.
*
* The properties included on each object include:
*
* ```js
* [
* {
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
* speed: 2926,
* times: {
* user: 252020,
* nice: 0,
* sys: 30340,
* idle: 1070356870,
* irq: 0
* }
* },
* {
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
* speed: 2926,
* times: {
* user: 306960,
* nice: 0,
* sys: 26980,
* idle: 1071569080,
* irq: 0
* }
* },
* {
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
* speed: 2926,
* times: {
* user: 248450,
* nice: 0,
* sys: 21750,
* idle: 1070919370,
* irq: 0
* }
* },
* {
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
* speed: 2926,
* times: {
* user: 256880,
* nice: 0,
* sys: 19430,
* idle: 1070905480,
* irq: 20
* }
* },
* ]
* ```
*
* `nice` values are POSIX-only. On Windows, the `nice` values of all processors
* are always 0.
* @since v0.3.3
*/
function cpus(): CpuInfo[];
/**
* Returns the operating system name as returned by [`uname(3)`](https://linux.die.net/man/3/uname). For example, it
* returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows.
*
* See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for additional information
* about the output of running [`uname(3)`](https://linux.die.net/man/3/uname) on various operating systems.
* @since v0.3.3
*/
function type(): string;
/**
* Returns the operating system as a string.
*
* On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `GetVersionExW()` is used. See
* [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
* @since v0.3.3
*/
function release(): string;
/**
* Returns an object containing network interfaces that have been assigned a
* network address.
*
* Each key on the returned object identifies a network interface. The associated
* value is an array of objects that each describe an assigned network address.
*
* The properties available on the assigned network address object include:
*
* ```js
* {
* lo: [
* {
* address: '127.0.0.1',
* netmask: '255.0.0.0',
* family: 'IPv4',
* mac: '00:00:00:00:00:00',
* internal: true,
* cidr: '127.0.0.1/8'
* },
* {
* address: '::1',
* netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
* family: 'IPv6',
* mac: '00:00:00:00:00:00',
* scopeid: 0,
* internal: true,
* cidr: '::1/128'
* }
* ],
* eth0: [
* {
* address: '192.168.1.108',
* netmask: '255.255.255.0',
* family: 'IPv4',
* mac: '01:02:03:0a:0b:0c',
* internal: false,
* cidr: '192.168.1.108/24'
* },
* {
* address: 'fe80::a00:27ff:fe4e:66a1',
* netmask: 'ffff:ffff:ffff:ffff::',
* family: 'IPv6',
* mac: '01:02:03:0a:0b:0c',
* scopeid: 1,
* internal: false,
* cidr: 'fe80::a00:27ff:fe4e:66a1/64'
* }
* ]
* }
* ```
* @since v0.6.0
*/
function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
/**
* Returns the string path of the current user's home directory.
*
* On POSIX, it uses the `$HOME` environment variable if defined. Otherwise it
* uses the [effective UID](https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID) to look up the user's home directory.
*
* On Windows, it uses the `USERPROFILE` environment variable if defined.
* Otherwise it uses the path to the profile directory of the current user.
* @since v2.3.0
*/
function homedir(): string;
/**
* Returns information about the currently effective user. On POSIX platforms,
* this is typically a subset of the password file. The returned object includes
* the `username`, `uid`, `gid`, `shell`, and `homedir`. On Windows, the `uid` and`gid` fields are `-1`, and `shell` is `null`.
*
* The value of `homedir` returned by `os.userInfo()` is provided by the operating
* system. This differs from the result of `os.homedir()`, which queries
* environment variables for the home directory before falling back to the
* operating system response.
*
* Throws a `SystemError` if a user has no `username` or `homedir`.
* @since v6.0.0
*/
function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
function userInfo(options?: { encoding: BufferEncoding }): UserInfo<string>;
type SignalConstants = {
[key in NodeJS.Signals]: number;
};
namespace constants {
const UV_UDP_REUSEADDR: number;
namespace signals {}
@ -210,34 +386,71 @@ declare module 'os' {
const PRIORITY_HIGHEST: number;
}
}
const devNull: string;
const EOL: string;
/**
* Returns the operating system CPU architecture for which the Node.js binary was
* compiled. Possible values are `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`, `'ppc64'`, `'s390'`, `'s390x'`, `'x32'`, and `'x64'`.
*
* The return value is equivalent to `process.arch`.
* @since v0.5.0
*/
function arch(): string;
/**
* Returns a string identifying the kernel version.
* On POSIX systems, the operating system release is determined by calling
* [uname(3)][]. On Windows, `pRtlGetVersion` is used, and if it is not available,
* `GetVersionExW()` will be used. See
* https://en.wikipedia.org/wiki/Uname#Examples for more information.
*
* On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used, and if it is not
* available, `GetVersionExW()` will be used. See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
* @since v13.11.0, v12.17.0
*/
function version(): string;
function platform(): NodeJS.Platform;
function tmpdir(): string;
const EOL: string;
function endianness(): "BE" | "LE";
/**
* Gets the priority of a process.
* Defaults to current process.
* Returns a string identifying the operating system platform. The value is set
* at compile time. Possible values are `'aix'`, `'darwin'`, `'freebsd'`,`'linux'`, `'openbsd'`, `'sunos'`, and `'win32'`.
*
* The return value is equivalent to `process.platform`.
*
* The value `'android'` may also be returned if Node.js is built on the Android
* operating system. [Android support is experimental](https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os).
* @since v0.5.0
*/
function platform(): NodeJS.Platform;
/**
* Returns the operating system's default directory for temporary files as a
* string.
* @since v0.9.9
*/
function tmpdir(): string;
/**
* Returns a string identifying the endianness of the CPU for which the Node.js
* binary was compiled.
*
* Possible values are `'BE'` for big endian and `'LE'` for little endian.
* @since v0.9.4
*/
function endianness(): 'BE' | 'LE';
/**
* Returns the scheduling priority for the process specified by `pid`. If `pid` is
* not provided or is `0`, the priority of the current process is returned.
* @since v10.10.0
* @param [pid=0] The process ID to retrieve scheduling priority for.
*/
function getPriority(pid?: number): number;
/**
* Sets the priority of the current process.
* @param priority Must be in range of -20 to 19
* Attempts to set the scheduling priority for the process specified by `pid`. If`pid` is not provided or is `0`, the process ID of the current process is used.
*
* The `priority` input must be an integer between `-20` (high priority) and `19`(low priority). Due to differences between Unix priority levels and Windows
* priority classes, `priority` is mapped to one of six priority constants in`os.constants.priority`. When retrieving a process priority level, this range
* mapping may cause the return value to be slightly different on Windows. To avoid
* confusion, set `priority` to one of the priority constants.
*
* On Windows, setting priority to `PRIORITY_HIGHEST` requires elevated user
* privileges. Otherwise the set priority will be silently reduced to`PRIORITY_HIGH`.
* @since v10.10.0
* @param [pid=0] The process ID to set scheduling priority for.
* @param priority The scheduling priority to assign to the process.
*/
function setPriority(priority: number): void;
/**
* Sets the priority of the process specified process.
* @param priority Must be in range of -20 to 19
*/
function setPriority(pid: number, priority: number): void;
}
declare module 'node:os' {

80
packages/node_modules/@node-red/editor-client/src/types/node/path.d.ts vendored
View File

@ -1,6 +1,23 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
declare module 'path/posix' {
import path = require('path');
export = path;
}
declare module 'path/win32' {
import path = require('path');
export = path;
}
/**
* The `path` module provides utilities for working with file and directory paths.
* It can be accessed using:
*
* ```js
* const path = require('path');
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/path.js)
*/
declare module 'path' {
namespace path {
/**
@ -28,7 +45,6 @@ declare module 'path' {
*/
name: string;
}
interface FormatInputPathObject {
/**
* The root of the path such as '/' or 'c:\'
@ -51,24 +67,24 @@ declare module 'path' {
*/
name?: string | undefined;
}
interface PlatformPath {
/**
* Normalize a string path, reducing '..' and '.' parts.
* When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
*
* @param p string path to normalize.
* @param path string path to normalize.
* @throws {TypeError} if `path` is not a string.
*/
normalize(p: string): string;
normalize(path: string): string;
/**
* Join all arguments together and normalize the resulting path.
* Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
*
* @param paths paths to join.
* @throws {TypeError} if any of the path segments is not a string.
*/
join(...paths: string[]): string;
/**
* The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
* The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
*
* Starting from leftmost {from} parameter, resolves {to} to an absolute path.
*
@ -77,61 +93,71 @@ declare module 'path' {
* the current working directory is used as well. The resulting path is normalized,
* and trailing slashes are removed unless the path gets resolved to the root directory.
*
* @param pathSegments string paths to join. Non-string arguments are ignored.
* @param paths string paths to join.
* @throws {TypeError} if any of the arguments is not a string.
*/
resolve(...pathSegments: string[]): string;
resolve(...paths: string[]): string;
/**
* Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
*
* If the given {path} is a zero-length string, `false` will be returned.
*
* @param path path to test.
* @throws {TypeError} if `path` is not a string.
*/
isAbsolute(p: string): boolean;
isAbsolute(path: string): boolean;
/**
* Solve the relative path from {from} to {to}.
* Solve the relative path from {from} to {to} based on the current working directory.
* At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
*
* @throws {TypeError} if either `from` or `to` is not a string.
*/
relative(from: string, to: string): string;
/**
* Return the directory name of a path. Similar to the Unix dirname command.
*
* @param p the path to evaluate.
* @param path the path to evaluate.
* @throws {TypeError} if `path` is not a string.
*/
dirname(p: string): string;
dirname(path: string): string;
/**
* Return the last portion of a path. Similar to the Unix basename command.
* Often used to extract the file name from a fully qualified path.
*
* @param p the path to evaluate.
* @param path the path to evaluate.
* @param ext optionally, an extension to remove from the result.
* @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string.
*/
basename(p: string, ext?: string): string;
basename(path: string, ext?: string): string;
/**
* Return the extension of the path, from the last '.' to end of string in the last portion of the path.
* If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string
* If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
*
* @param p the path to evaluate.
* @param path the path to evaluate.
* @throws {TypeError} if `path` is not a string.
*/
extname(p: string): string;
extname(path: string): string;
/**
* The platform-specific file separator. '\\' or '/'.
*/
readonly sep: string;
readonly sep: '\\' | '/';
/**
* The platform-specific file delimiter. ';' or ':'.
*/
readonly delimiter: string;
readonly delimiter: ';' | ':';
/**
* Returns an object from a path string - the opposite of format().
*
* @param pathString path to evaluate.
* @param path path to evaluate.
* @throws {TypeError} if `path` is not a string.
*/
parse(p: string): ParsedPath;
parse(path: string): ParsedPath;
/**
* Returns a path string from an object - the opposite of parse().
*
* @param pathString path to evaluate.
* @param pathObject path to evaluate.
*/
format(pP: FormatInputPathObject): string;
format(pathObject: FormatInputPathObject): string;
/**
* On Windows systems only, returns an equivalent namespace-prefixed path for the given path.
* If path is not a string, path will be returned without modifications.
@ -158,3 +184,11 @@ declare module 'node:path' {
import path = require('path');
export = path;
}
declare module 'node:path/posix' {
import path = require('path/posix');
export = path;
}
declare module 'node:path/win32' {
import path = require('path/win32');
export = path;
}

570
packages/node_modules/@node-red/editor-client/src/types/node/perf_hooks.d.ts vendored
View File

@ -1,41 +1,46 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for
* Node.js-specific performance measurements.
*
* Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/):
*
* * [High Resolution Time](https://www.w3.org/TR/hr-time-2)
* * [Performance Timeline](https://w3c.github.io/performance-timeline/)
* * [User Timing](https://www.w3.org/TR/user-timing/)
*
* ```js
* const { PerformanceObserver, performance } = require('perf_hooks');
*
* const obs = new PerformanceObserver((items) => {
* console.log(items.getEntries()[0].duration);
* performance.clearMarks();
* });
* obs.observe({ type: 'measure' });
* performance.measure('Start to Now');
*
* performance.mark('A');
* doSomeLongRunningProcess(() => {
* performance.measure('A to Now', 'A');
*
* performance.mark('B');
* performance.measure('A to B', 'A', 'B');
* });
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/perf_hooks.js)
*/
declare module 'perf_hooks' {
import { AsyncResource } from 'async_hooks';
import { AsyncResource } from 'node:async_hooks';
type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http';
interface PerformanceEntry {
/**
* The total number of milliseconds elapsed for this entry.
* This value will not be meaningful for all Performance Entry types.
*/
readonly duration: number;
/**
* The name of the performance entry.
*/
readonly name: string;
/**
* The high resolution millisecond timestamp marking the starting time of the Performance Entry.
*/
readonly startTime: number;
/**
* The type of the performance entry.
* Currently it may be one of: 'node', 'mark', 'measure', 'gc', or 'function'.
*/
readonly entryType: EntryType;
interface NodeGCPerformanceDetail {
/**
* When `performanceEntry.entryType` is equal to 'gc', `the performance.kind` property identifies
* the type of garbage collection operation that occurred.
* See perf_hooks.constants for valid values.
*/
readonly kind?: number | undefined;
/**
* When `performanceEntry.entryType` is equal to 'gc', the `performance.flags`
* property contains additional information about garbage collection operation.
@ -43,50 +48,145 @@ declare module 'perf_hooks' {
*/
readonly flags?: number | undefined;
}
interface PerformanceNodeTiming extends PerformanceEntry {
/**
* @since v8.5.0
*/
class PerformanceEntry {
protected constructor();
/**
* The high resolution millisecond timestamp at which the Node.js process completed bootstrap.
* The total number of milliseconds elapsed for this entry. This value will not
* be meaningful for all Performance Entry types.
* @since v8.5.0
*/
readonly duration: number;
/**
* The name of the performance entry.
* @since v8.5.0
*/
readonly name: string;
/**
* The high resolution millisecond timestamp marking the starting time of the
* Performance Entry.
* @since v8.5.0
*/
readonly startTime: number;
/**
* The type of the performance entry. It may be one of:
*
* * `'node'` (Node.js only)
* * `'mark'` (available on the Web)
* * `'measure'` (available on the Web)
* * `'gc'` (Node.js only)
* * `'function'` (Node.js only)
* * `'http2'` (Node.js only)
* * `'http'` (Node.js only)
* @since v8.5.0
*/
readonly entryType: EntryType;
/**
* Additional detail specific to the `entryType`.
* @since v16.0.0
*/
readonly detail?: NodeGCPerformanceDetail | unknown | undefined; // TODO: Narrow this based on entry type.
}
/**
* _This property is an extension by Node.js. It is not available in Web browsers._
*
* Provides timing details for Node.js itself. The constructor of this class
* is not exposed to users.
* @since v8.5.0
*/
class PerformanceNodeTiming extends PerformanceEntry {
/**
* The high resolution millisecond timestamp at which the Node.js process
* completed bootstrapping. If bootstrapping has not yet finished, the property
* has the value of -1.
* @since v8.5.0
*/
readonly bootstrapComplete: number;
/**
* The high resolution millisecond timestamp at which the Node.js process completed bootstrapping.
* If bootstrapping has not yet finished, the property has the value of -1.
* The high resolution millisecond timestamp at which the Node.js environment was
* initialized.
* @since v8.5.0
*/
readonly environment: number;
/**
* The high resolution millisecond timestamp at which the Node.js environment was initialized.
* The high resolution millisecond timestamp of the amount of time the event loop
* has been idle within the event loop's event provider (e.g. `epoll_wait`). This
* does not take CPU usage into consideration. If the event loop has not yet
* started (e.g., in the first tick of the main script), the property has the
* value of 0.
* @since v14.10.0, v12.19.0
*/
readonly idleTime: number;
/**
* The high resolution millisecond timestamp of the amount of time the event loop has been idle
* within the event loop's event provider (e.g. `epoll_wait`). This does not take CPU usage
* into consideration. If the event loop has not yet started (e.g., in the first tick of the main script),
* the property has the value of 0.
* The high resolution millisecond timestamp at which the Node.js event loop
* exited. If the event loop has not yet exited, the property has the value of -1\.
* It can only have a value of not -1 in a handler of the `'exit'` event.
* @since v8.5.0
*/
readonly loopExit: number;
/**
* The high resolution millisecond timestamp at which the Node.js event loop started.
* If the event loop has not yet started (e.g., in the first tick of the main script), the property has the value of -1.
* The high resolution millisecond timestamp at which the Node.js event loop
* started. If the event loop has not yet started (e.g., in the first tick of the
* main script), the property has the value of -1.
* @since v8.5.0
*/
readonly loopStart: number;
/**
* The high resolution millisecond timestamp at which the V8 platform was initialized.
* The high resolution millisecond timestamp at which the V8 platform was
* initialized.
* @since v8.5.0
*/
readonly v8Start: number;
}
interface EventLoopUtilization {
idle: number;
active: number;
utilization: number;
}
/**
* @param util1 The result of a previous call to eventLoopUtilization()
* @param util2 The result of a previous call to eventLoopUtilization() prior to util1
*/
type EventLoopUtilityFunction = (util1?: EventLoopUtilization, util2?: EventLoopUtilization) => EventLoopUtilization;
interface MarkOptions {
/**
* Additional optional detail to include with the mark.
*/
detail?: unknown | undefined;
/**
* An optional timestamp to be used as the mark time.
* @default `performance.now()`.
*/
startTime?: number | undefined;
}
interface MeasureOptions {
/**
* Additional optional detail to include with the mark.
*/
detail?: unknown | undefined;
/**
* Duration between start and end times.
*/
duration?: number | undefined;
/**
* Timestamp to be used as the end time, or a string identifying a previously recorded mark.
*/
end?: number | string | undefined;
/**
* Timestamp to be used as the start time, or a string identifying a previously recorded mark.
*/
start?: number | string | undefined;
}
interface TimerifyOptions {
/**
* A histogram object created using
* `perf_hooks.createHistogram()` that will record runtime durations in
* nanoseconds.
*/
histogram?: RecordableHistogram | undefined;
}
interface Performance {
/**
* If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
@ -94,7 +194,35 @@ declare module 'perf_hooks' {
* @param name
*/
clearMarks(name?: string): void;
/**
* If name is not provided, removes all PerformanceMeasure objects from the Performance Timeline.
* If name is provided, removes only the named measure.
* @param name
* @since v16.7.0
*/
clearMeasures(name?: string): void;
/**
* Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`.
* If you are only interested in performance entries of certain types or that have certain names, see
* `performance.getEntriesByType()` and `performance.getEntriesByName()`.
* @since v16.7.0
*/
getEntries(): PerformanceEntry[];
/**
* Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
* whose `performanceEntry.name` is equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to `type`.
* @param name
* @param type
* @since v16.7.0
*/
getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
/**
* Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
* whose `performanceEntry.entryType` is equal to `type`.
* @param type
* @since v16.7.0
*/
getEntriesByType(type: EntryType): PerformanceEntry[];
/**
* Creates a new PerformanceMark entry in the Performance Timeline.
* A PerformanceMark is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'mark',
@ -102,8 +230,7 @@ declare module 'perf_hooks' {
* Performance marks are used to mark specific significant moments in the Performance Timeline.
* @param name
*/
mark(name?: string): void;
mark(name?: string, options?: MarkOptions): void;
/**
* Creates a new PerformanceMeasure entry in the Performance Timeline.
* A PerformanceMeasure is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'measure',
@ -120,84 +247,201 @@ declare module 'perf_hooks' {
* @param endMark
*/
measure(name: string, startMark?: string, endMark?: string): void;
measure(name: string, options: MeasureOptions): void;
/**
* An instance of the PerformanceNodeTiming class that provides performance metrics for specific Node.js operational milestones.
*/
readonly nodeTiming: PerformanceNodeTiming;
/**
* @return the current high resolution millisecond timestamp
*/
now(): number;
/**
* The timeOrigin specifies the high resolution millisecond timestamp from which all performance metric durations are measured.
*/
readonly timeOrigin: number;
/**
* Wraps a function within a new function that measures the running time of the wrapped function.
* A PerformanceObserver must be subscribed to the 'function' event type in order for the timing details to be accessed.
* @param fn
*/
timerify<T extends (...optionalParams: any[]) => any>(fn: T): T;
timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
/**
* eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
* It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
* No other CPU idle time is taken into consideration.
*
* @param util1 The result of a previous call to eventLoopUtilization()
* @param util2 The result of a previous call to eventLoopUtilization() prior to util1
*/
eventLoopUtilization(util1?: EventLoopUtilization, util2?: EventLoopUtilization): EventLoopUtilization;
eventLoopUtilization: EventLoopUtilityFunction;
}
interface PerformanceObserverEntryList {
/**
* @return a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime.
* Returns a list of `PerformanceEntry` objects in chronological order
* with respect to `performanceEntry.startTime`.
*
* ```js
* const {
* performance,
* PerformanceObserver
* } = require('perf_hooks');
*
* const obs = new PerformanceObserver((perfObserverList, observer) => {
* console.log(perfObserverList.getEntries());
*
* * [
* * PerformanceEntry {
* * name: 'test',
* * entryType: 'mark',
* * startTime: 81.465639,
* * duration: 0
* * },
* * PerformanceEntry {
* * name: 'meow',
* * entryType: 'mark',
* * startTime: 81.860064,
* * duration: 0
* * }
* * ]
*
* observer.disconnect();
* });
* obs.observe({ type: 'mark' });
*
* performance.mark('test');
* performance.mark('meow');
* ```
* @since v8.5.0
*/
getEntries(): PerformanceEntry[];
/**
* @return a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
* whose performanceEntry.name is equal to name, and optionally, whose performanceEntry.entryType is equal to type.
* Returns a list of `PerformanceEntry` objects in chronological order
* with respect to `performanceEntry.startTime` whose `performanceEntry.name` is
* equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to`type`.
*
* ```js
* const {
* performance,
* PerformanceObserver
* } = require('perf_hooks');
*
* const obs = new PerformanceObserver((perfObserverList, observer) => {
* console.log(perfObserverList.getEntriesByName('meow'));
*
* * [
* * PerformanceEntry {
* * name: 'meow',
* * entryType: 'mark',
* * startTime: 98.545991,
* * duration: 0
* * }
* * ]
*
* console.log(perfObserverList.getEntriesByName('nope')); // []
*
* console.log(perfObserverList.getEntriesByName('test', 'mark'));
*
* * [
* * PerformanceEntry {
* * name: 'test',
* * entryType: 'mark',
* * startTime: 63.518931,
* * duration: 0
* * }
* * ]
*
* console.log(perfObserverList.getEntriesByName('test', 'measure')); // []
* observer.disconnect();
* });
* obs.observe({ entryTypes: ['mark', 'measure'] });
*
* performance.mark('test');
* performance.mark('meow');
* ```
* @since v8.5.0
*/
getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
/**
* @return Returns a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
* whose performanceEntry.entryType is equal to type.
* Returns a list of `PerformanceEntry` objects in chronological order
* with respect to `performanceEntry.startTime` whose `performanceEntry.entryType`is equal to `type`.
*
* ```js
* const {
* performance,
* PerformanceObserver
* } = require('perf_hooks');
*
* const obs = new PerformanceObserver((perfObserverList, observer) => {
* console.log(perfObserverList.getEntriesByType('mark'));
*
* * [
* * PerformanceEntry {
* * name: 'test',
* * entryType: 'mark',
* * startTime: 55.897834,
* * duration: 0
* * },
* * PerformanceEntry {
* * name: 'meow',
* * entryType: 'mark',
* * startTime: 56.350146,
* * duration: 0
* * }
* * ]
*
* observer.disconnect();
* });
* obs.observe({ type: 'mark' });
*
* performance.mark('test');
* performance.mark('meow');
* ```
* @since v8.5.0
*/
getEntriesByType(type: EntryType): PerformanceEntry[];
}
type PerformanceObserverCallback = (list: PerformanceObserverEntryList, observer: PerformanceObserver) => void;
class PerformanceObserver extends AsyncResource {
constructor(callback: PerformanceObserverCallback);
/**
* Disconnects the PerformanceObserver instance from all notifications.
* Disconnects the `PerformanceObserver` instance from all notifications.
* @since v8.5.0
*/
disconnect(): void;
/**
* Subscribes the PerformanceObserver instance to notifications of new PerformanceEntry instances identified by options.entryTypes.
* When options.buffered is false, the callback will be invoked once for every PerformanceEntry instance.
* Property buffered defaults to false.
* @param options
* Subscribes the `PerformanceObserver` instance to notifications of new `PerformanceEntry` instances identified either by `options.entryTypes`or `options.type`:
*
* ```js
* const {
* performance,
* PerformanceObserver
* } = require('perf_hooks');
*
* const obs = new PerformanceObserver((list, observer) => {
* // Called three times synchronously. `list` contains one item.
* });
* obs.observe({ type: 'mark' });
*
* for (let n = 0; n < 3; n++)
* performance.mark(`test${n}`);
* ```
* @since v8.5.0
*/
observe(options: { entryTypes: ReadonlyArray<EntryType>; buffered?: boolean | undefined }): void;
observe(
options:
| {
entryTypes: ReadonlyArray<EntryType>;
buffered?: boolean | undefined;
}
| {
type: EntryType;
buffered?: boolean | undefined;
}
): void;
}
namespace constants {
const NODE_PERFORMANCE_GC_MAJOR: number;
const NODE_PERFORMANCE_GC_MINOR: number;
const NODE_PERFORMANCE_GC_INCREMENTAL: number;
const NODE_PERFORMANCE_GC_WEAKCB: number;
const NODE_PERFORMANCE_GC_FLAGS_NO: number;
const NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: number;
const NODE_PERFORMANCE_GC_FLAGS_FORCED: number;
@ -206,9 +450,7 @@ declare module 'perf_hooks' {
const NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: number;
const NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: number;
}
const performance: Performance;
interface EventLoopMonitorOptions {
/**
* The sampling rate in milliseconds.
@ -217,60 +459,130 @@ declare module 'perf_hooks' {
*/
resolution?: number | undefined;
}
interface EventLoopDelayMonitor {
interface Histogram {
/**
* Enables the event loop delay sample timer. Returns `true` if the timer was started, `false` if it was already started.
* Returns a `Map` object detailing the accumulated percentile distribution.
* @since v11.10.0
*/
readonly percentiles: Map<number, number>;
/**
* The number of times the event loop delay exceeded the maximum 1 hour event
* loop delay threshold.
* @since v11.10.0
*/
readonly exceeds: number;
/**
* The minimum recorded event loop delay.
* @since v11.10.0
*/
readonly min: number;
/**
* The maximum recorded event loop delay.
* @since v11.10.0
*/
readonly max: number;
/**
* The mean of the recorded event loop delays.
* @since v11.10.0
*/
readonly mean: number;
/**
* The standard deviation of the recorded event loop delays.
* @since v11.10.0
*/
readonly stddev: number;
/**
* Resets the collected histogram data.
* @since v11.10.0
*/
reset(): void;
/**
* Returns the value at the given percentile.
* @since v11.10.0
* @param percentile A percentile value in the range (0, 100].
*/
percentile(percentile: number): number;
}
interface IntervalHistogram extends Histogram {
/**
* Enables the update interval timer. Returns `true` if the timer was
* started, `false` if it was already started.
* @since v11.10.0
*/
enable(): boolean;
/**
* Disables the event loop delay sample timer. Returns `true` if the timer was stopped, `false` if it was already stopped.
* Disables the update interval timer. Returns `true` if the timer was
* stopped, `false` if it was already stopped.
* @since v11.10.0
*/
disable(): boolean;
/**
* Resets the collected histogram data.
*/
reset(): void;
/**
* Returns the value at the given percentile.
* @param percentile A percentile value between 1 and 100.
*/
percentile(percentile: number): number;
/**
* A `Map` object detailing the accumulated percentile distribution.
*/
readonly percentiles: Map<number, number>;
/**
* The number of times the event loop delay exceeded the maximum 1 hour eventloop delay threshold.
*/
readonly exceeds: number;
/**
* The minimum recorded event loop delay.
*/
readonly min: number;
/**
* The maximum recorded event loop delay.
*/
readonly max: number;
/**
* The mean of the recorded event loop delays.
*/
readonly mean: number;
/**
* The standard deviation of the recorded event loop delays.
*/
readonly stddev: number;
}
function monitorEventLoopDelay(options?: EventLoopMonitorOptions): EventLoopDelayMonitor;
interface RecordableHistogram extends Histogram {
/**
* @since v15.9.0
* @param val The amount to record in the histogram.
*/
record(val: number | bigint): void;
/**
* Calculates the amount of time (in nanoseconds) that has passed since the
* previous call to `recordDelta()` and records that amount in the histogram.
*
* ## Examples
* @since v15.9.0
*/
recordDelta(): void;
}
/**
* _This property is an extension by Node.js. It is not available in Web browsers._
*
* Creates an `IntervalHistogram` object that samples and reports the event loop
* delay over time. The delays will be reported in nanoseconds.
*
* Using a timer to detect approximate event loop delay works because the
* execution of timers is tied specifically to the lifecycle of the libuv
* event loop. That is, a delay in the loop will cause a delay in the execution
* of the timer, and those delays are specifically what this API is intended to
* detect.
*
* ```js
* const { monitorEventLoopDelay } = require('perf_hooks');
* const h = monitorEventLoopDelay({ resolution: 20 });
* h.enable();
* // Do something.
* h.disable();
* console.log(h.min);
* console.log(h.max);
* console.log(h.mean);
* console.log(h.stddev);
* console.log(h.percentiles);
* console.log(h.percentile(50));
* console.log(h.percentile(99));
* ```
* @since v11.10.0
*/
function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
interface CreateHistogramOptions {
/**
* The minimum recordable value. Must be an integer value greater than 0.
* @default 1
*/
min?: number | bigint | undefined;
/**
* The maximum recordable value. Must be an integer value greater than min.
* @default Number.MAX_SAFE_INTEGER
*/
max?: number | bigint | undefined;
/**
* The number of accuracy digits. Must be a number between 1 and 5.
* @default 3
*/
figures?: number | undefined;
}
/**
* Returns a `RecordableHistogram`.
* @since v15.9.0
*/
function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
}
declare module 'node:perf_hooks' {
export * from 'perf_hooks';

1454
packages/node_modules/@node-red/editor-client/src/types/node/process.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

114
packages/node_modules/@node-red/editor-client/src/types/node/querystring.d.ts vendored
View File

@ -1,22 +1,98 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `querystring` module provides utilities for parsing and formatting URL
* query strings. It can be accessed using:
*
* ```js
* const querystring = require('querystring');
* ```
*
* `querystring` is more performant than `URLSearchParams` but is not a
* standardized API. Use `URLSearchParams` when performance is not critical
* or when compatibility with browser code is desirable.
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/querystring.js)
*/
declare module 'querystring' {
interface StringifyOptions {
encodeURIComponent?: ((str: string) => string) | undefined;
}
interface ParseOptions {
maxKeys?: number | undefined;
decodeURIComponent?: ((str: string) => string) | undefined;
}
interface ParsedUrlQuery extends NodeJS.Dict<string | string[]> { }
interface ParsedUrlQueryInput extends NodeJS.Dict<string | number | boolean | ReadonlyArray<string> | ReadonlyArray<number> | ReadonlyArray<boolean> | null> {
}
interface ParsedUrlQuery extends NodeJS.Dict<string | string[]> {}
interface ParsedUrlQueryInput extends NodeJS.Dict<string | number | boolean | ReadonlyArray<string> | ReadonlyArray<number> | ReadonlyArray<boolean> | null> {}
/**
* The `querystring.stringify()` method produces a URL query string from a
* given `obj` by iterating through the object's "own properties".
*
* It serializes the following types of values passed in `obj`:[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) |
* [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) |
* [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) |
* [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) |
* [string\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) |
* [number\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) |
* [bigint\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) |
* [boolean\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) The numeric values must be finite. Any other input values will be coerced to
* empty strings.
*
* ```js
* querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });
* // Returns 'foo=bar&#x26;baz=qux&#x26;baz=quux&#x26;corge='
*
* querystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':');
* // Returns 'foo:bar;baz:qux'
* ```
*
* By default, characters requiring percent-encoding within the query string will
* be encoded as UTF-8\. If an alternative encoding is required, then an alternative`encodeURIComponent` option will need to be specified:
*
* ```js
* // Assuming gbkEncodeURIComponent function already exists,
*
* querystring.stringify({ w: '中文', foo: 'bar' }, null, null,
* { encodeURIComponent: gbkEncodeURIComponent });
* ```
* @since v0.1.25
* @param obj The object to serialize into a URL query string
* @param [sep='&'] The substring used to delimit key and value pairs in the query string.
* @param [eq='='] . The substring used to delimit keys and values in the query string.
*/
function stringify(obj?: ParsedUrlQueryInput, sep?: string, eq?: string, options?: StringifyOptions): string;
/**
* The `querystring.parse()` method parses a URL query string (`str`) into a
* collection of key and value pairs.
*
* For example, the query string `'foo=bar&#x26;abc=xyz&#x26;abc=123'` is parsed into:
*
* ```js
* {
* foo: 'bar',
* abc: ['xyz', '123']
* }
* ```
*
* The object returned by the `querystring.parse()` method _does not_prototypically inherit from the JavaScript `Object`. This means that typical`Object` methods such as `obj.toString()`,
* `obj.hasOwnProperty()`, and others
* are not defined and _will not work_.
*
* By default, percent-encoded characters within the query string will be assumed
* to use UTF-8 encoding. If an alternative character encoding is used, then an
* alternative `decodeURIComponent` option will need to be specified:
*
* ```js
* // Assuming gbkDecodeURIComponent function already exists...
*
* querystring.parse('w=%D6%D0%CE%C4&#x26;foo=bar', null, null,
* { decodeURIComponent: gbkDecodeURIComponent });
* ```
* @since v0.1.25
* @param str The URL query string to parse
* @param [sep='&'] The substring used to delimit key and value pairs in the query string.
* @param [eq='='] . The substring used to delimit keys and values in the query string.
*/
function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): ParsedUrlQuery;
/**
* The querystring.encode() function is an alias for querystring.stringify().
@ -26,7 +102,31 @@ declare module 'querystring' {
* The querystring.decode() function is an alias for querystring.parse().
*/
const decode: typeof parse;
/**
* The `querystring.escape()` method performs URL percent-encoding on the given`str` in a manner that is optimized for the specific requirements of URL
* query strings.
*
* The `querystring.escape()` method is used by `querystring.stringify()` and is
* generally not expected to be used directly. It is exported primarily to allow
* application code to provide a replacement percent-encoding implementation if
* necessary by assigning `querystring.escape` to an alternative function.
* @since v0.1.25
*/
function escape(str: string): string;
/**
* The `querystring.unescape()` method performs decoding of URL percent-encoded
* characters on the given `str`.
*
* The `querystring.unescape()` method is used by `querystring.parse()` and is
* generally not expected to be used directly. It is exported primarily to allow
* application code to provide a replacement decoding implementation if
* necessary by assigning `querystring.unescape` to an alternative function.
*
* By default, the `querystring.unescape()` method will attempt to use the
* JavaScript built-in `decodeURIComponent()` method to decode. If that fails,
* a safer equivalent that does not throw on malformed URLs will be used.
* @since v0.1.25
*/
function unescape(str: string): string;
}
declare module 'node:querystring' {

517
packages/node_modules/@node-red/editor-client/src/types/node/readline.d.ts vendored
View File

@ -1,9 +1,38 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time. It can be accessed
* using:
*
* ```js
* const readline = require('readline');
* ```
*
* The following simple example illustrates the basic use of the `readline` module.
*
* ```js
* const readline = require('readline');
*
* const rl = readline.createInterface({
* input: process.stdin,
* output: process.stdout
* });
*
* rl.question('What do you think of Node.js? ', (answer) => {
* // TODO: Log the answer in a database
* console.log(`Thank you for your valuable feedback: ${answer}`);
*
* rl.close();
* });
* ```
*
* Once this code is invoked, the Node.js application will not terminate until the`readline.Interface` is closed because the interface waits for data to be
* received on the `input` stream.
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/readline.js)
*/
declare module 'readline' {
import EventEmitter = require('events');
import { Abortable, EventEmitter } from 'node:events';
interface Key {
sequence?: string | undefined;
name?: string | undefined;
@ -11,17 +40,56 @@ declare module 'readline' {
meta?: boolean | undefined;
shift?: boolean | undefined;
}
/**
* Instances of the `readline.Interface` class are constructed using the`readline.createInterface()` method. Every instance is associated with a
* single `input` `Readable` stream and a single `output` `Writable` stream.
* The `output` stream is used to print prompts for user input that arrives on,
* and is read from, the `input` stream.
* @since v0.1.104
*/
class Interface extends EventEmitter {
readonly terminal: boolean;
// Need direct access to line/cursor data, for use in external processes
// see: https://github.com/nodejs/node/issues/30347
/** The current input data */
/**
* The current input data being processed by node.
*
* This can be used when collecting input from a TTY stream to retrieve the
* current value that has been processed thus far, prior to the `line` event
* being emitted. Once the `line` event has been emitted, this property will
* be an empty string.
*
* Be aware that modifying the value during the instance runtime may have
* unintended consequences if `rl.cursor` is not also controlled.
*
* **If not using a TTY stream for input, use the `'line'` event.**
*
* One possible use case would be as follows:
*
* ```js
* const values = ['lorem ipsum', 'dolor sit amet'];
* const rl = readline.createInterface(process.stdin);
* const showResults = debounce(() => {
* console.log(
* '\n',
* values.filter((val) => val.startsWith(rl.line)).join(' ')
* );
* }, 300);
* process.stdin.on('keypress', (c, k) => {
* showResults();
* });
* ```
* @since v0.1.98
*/
readonly line: string;
/** The current cursor position in the input line */
/**
* The cursor position relative to `rl.line`.
*
* This will track where the current cursor lands in the input string, when
* reading input from a TTY stream. The position of cursor determines the
* portion of the input string that will be modified as input is processed,
* as well as the column where the terminal caret will be rendered.
* @since v0.1.98
*/
readonly cursor: number;
/**
* NOTE: According to the documentation:
*
@ -40,23 +108,145 @@ declare module 'readline' {
* @see https://nodejs.org/dist/latest-v10.x/docs/api/readline.html#readline_class_interface
*/
protected constructor(options: ReadLineOptions);
/**
* The `rl.getPrompt()` method returns the current prompt used by `rl.prompt()`.
* @since v15.3.0
* @return the current prompt string
*/
getPrompt(): string;
/**
* The `rl.setPrompt()` method sets the prompt that will be written to `output`whenever `rl.prompt()` is called.
* @since v0.1.98
*/
setPrompt(prompt: string): void;
/**
* The `rl.prompt()` method writes the `readline.Interface` instances configured`prompt` to a new line in `output` in order to provide a user with a new
* location at which to provide input.
*
* When called, `rl.prompt()` will resume the `input` stream if it has been
* paused.
*
* If the `readline.Interface` was created with `output` set to `null` or`undefined` the prompt is not written.
* @since v0.1.98
* @param preserveCursor If `true`, prevents the cursor placement from being reset to `0`.
*/
prompt(preserveCursor?: boolean): void;
/**
* The `rl.question()` method displays the `query` by writing it to the `output`,
* waits for user input to be provided on `input`, then invokes the `callback`function passing the provided input as the first argument.
*
* When called, `rl.question()` will resume the `input` stream if it has been
* paused.
*
* If the `readline.Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
*
* The `callback` function passed to `rl.question()` does not follow the typical
* pattern of accepting an `Error` object or `null` as the first argument.
* The `callback` is called with the provided answer as the only argument.
*
* Example usage:
*
* ```js
* rl.question('What is your favorite food? ', (answer) => {
* console.log(`Oh, so your favorite food is ${answer}`);
* });
* ```
*
* Using an `AbortController` to cancel a question.
*
* ```js
* const ac = new AbortController();
* const signal = ac.signal;
*
* rl.question('What is your favorite food? ', { signal }, (answer) => {
* console.log(`Oh, so your favorite food is ${answer}`);
* });
*
* signal.addEventListener('abort', () => {
* console.log('The food question timed out');
* }, { once: true });
*
* setTimeout(() => ac.abort(), 10000);
* ```
*
* If this method is invoked as it's util.promisify()ed version, it returns a
* Promise that fulfills with the answer. If the question is canceled using
* an `AbortController` it will reject with an `AbortError`.
*
* ```js
* const util = require('util');
* const question = util.promisify(rl.question).bind(rl);
*
* async function questionExample() {
* try {
* const answer = await question('What is you favorite food? ');
* console.log(`Oh, so your favorite food is ${answer}`);
* } catch (err) {
* console.error('Question rejected', err);
* }
* }
* questionExample();
* ```
* @since v0.3.3
* @param query A statement or query to write to `output`, prepended to the prompt.
* @param callback A callback function that is invoked with the user's input in response to the `query`.
*/
question(query: string, callback: (answer: string) => void): void;
question(query: string, options: Abortable, callback: (answer: string) => void): void;
/**
* The `rl.pause()` method pauses the `input` stream, allowing it to be resumed
* later if necessary.
*
* Calling `rl.pause()` does not immediately pause other events (including`'line'`) from being emitted by the `readline.Interface` instance.
* @since v0.3.4
*/
pause(): this;
/**
* The `rl.resume()` method resumes the `input` stream if it has been paused.
* @since v0.3.4
*/
resume(): this;
/**
* The `rl.close()` method closes the `readline.Interface` instance and
* relinquishes control over the `input` and `output` streams. When called,
* the `'close'` event will be emitted.
*
* Calling `rl.close()` does not immediately stop other events (including `'line'`)
* from being emitted by the `readline.Interface` instance.
* @since v0.1.98
*/
close(): void;
/**
* The `rl.write()` method will write either `data` or a key sequence identified
* by `key` to the `output`. The `key` argument is supported only if `output` is
* a `TTY` text terminal. See `TTY keybindings` for a list of key
* combinations.
*
* If `key` is specified, `data` is ignored.
*
* When called, `rl.write()` will resume the `input` stream if it has been
* paused.
*
* If the `readline.Interface` was created with `output` set to `null` or`undefined` the `data` and `key` are not written.
*
* ```js
* rl.write('Delete this!');
* // Simulate Ctrl+U to delete the line written previously
* rl.write(null, { ctrl: true, name: 'u' });
* ```
*
* The `rl.write()` method will write the data to the `readline` `Interface`'s`input`_as if it were provided by the user_.
* @since v0.1.98
*/
write(data: string | Buffer, key?: Key): void;
write(data: undefined | null | string | Buffer, key: Key): void;
/**
* Returns the real position of the cursor in relation to the input
* prompt + string. Long input (wrapping) strings, as well as multiple
* prompt + string. Long input (wrapping) strings, as well as multiple
* line prompts are included in the calculations.
* @since v13.5.0, v12.16.0
*/
getCursorPos(): CursorPos;
/**
* events.EventEmitter
* 1. close
@ -66,109 +256,288 @@ declare module 'readline' {
* 5. SIGCONT
* 6. SIGINT
* 7. SIGTSTP
* 8. history
*/
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "close", listener: () => void): this;
addListener(event: "line", listener: (input: string) => void): this;
addListener(event: "pause", listener: () => void): this;
addListener(event: "resume", listener: () => void): this;
addListener(event: "SIGCONT", listener: () => void): this;
addListener(event: "SIGINT", listener: () => void): this;
addListener(event: "SIGTSTP", listener: () => void): this;
addListener(event: 'close', listener: () => void): this;
addListener(event: 'line', listener: (input: string) => void): this;
addListener(event: 'pause', listener: () => void): this;
addListener(event: 'resume', listener: () => void): this;
addListener(event: 'SIGCONT', listener: () => void): this;
addListener(event: 'SIGINT', listener: () => void): this;
addListener(event: 'SIGTSTP', listener: () => void): this;
addListener(event: 'history', listener: (history: string[]) => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "close"): boolean;
emit(event: "line", input: string): boolean;
emit(event: "pause"): boolean;
emit(event: "resume"): boolean;
emit(event: "SIGCONT"): boolean;
emit(event: "SIGINT"): boolean;
emit(event: "SIGTSTP"): boolean;
emit(event: 'close'): boolean;
emit(event: 'line', input: string): boolean;
emit(event: 'pause'): boolean;
emit(event: 'resume'): boolean;
emit(event: 'SIGCONT'): boolean;
emit(event: 'SIGINT'): boolean;
emit(event: 'SIGTSTP'): boolean;
emit(event: 'history', history: string[]): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "close", listener: () => void): this;
on(event: "line", listener: (input: string) => void): this;
on(event: "pause", listener: () => void): this;
on(event: "resume", listener: () => void): this;
on(event: "SIGCONT", listener: () => void): this;
on(event: "SIGINT", listener: () => void): this;
on(event: "SIGTSTP", listener: () => void): this;
on(event: 'close', listener: () => void): this;
on(event: 'line', listener: (input: string) => void): this;
on(event: 'pause', listener: () => void): this;
on(event: 'resume', listener: () => void): this;
on(event: 'SIGCONT', listener: () => void): this;
on(event: 'SIGINT', listener: () => void): this;
on(event: 'SIGTSTP', listener: () => void): this;
on(event: 'history', listener: (history: string[]) => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "close", listener: () => void): this;
once(event: "line", listener: (input: string) => void): this;
once(event: "pause", listener: () => void): this;
once(event: "resume", listener: () => void): this;
once(event: "SIGCONT", listener: () => void): this;
once(event: "SIGINT", listener: () => void): this;
once(event: "SIGTSTP", listener: () => void): this;
once(event: 'close', listener: () => void): this;
once(event: 'line', listener: (input: string) => void): this;
once(event: 'pause', listener: () => void): this;
once(event: 'resume', listener: () => void): this;
once(event: 'SIGCONT', listener: () => void): this;
once(event: 'SIGINT', listener: () => void): this;
once(event: 'SIGTSTP', listener: () => void): this;
once(event: 'history', listener: (history: string[]) => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "close", listener: () => void): this;
prependListener(event: "line", listener: (input: string) => void): this;
prependListener(event: "pause", listener: () => void): this;
prependListener(event: "resume", listener: () => void): this;
prependListener(event: "SIGCONT", listener: () => void): this;
prependListener(event: "SIGINT", listener: () => void): this;
prependListener(event: "SIGTSTP", listener: () => void): this;
prependListener(event: 'close', listener: () => void): this;
prependListener(event: 'line', listener: (input: string) => void): this;
prependListener(event: 'pause', listener: () => void): this;
prependListener(event: 'resume', listener: () => void): this;
prependListener(event: 'SIGCONT', listener: () => void): this;
prependListener(event: 'SIGINT', listener: () => void): this;
prependListener(event: 'SIGTSTP', listener: () => void): this;
prependListener(event: 'history', listener: (history: string[]) => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "close", listener: () => void): this;
prependOnceListener(event: "line", listener: (input: string) => void): this;
prependOnceListener(event: "pause", listener: () => void): this;
prependOnceListener(event: "resume", listener: () => void): this;
prependOnceListener(event: "SIGCONT", listener: () => void): this;
prependOnceListener(event: "SIGINT", listener: () => void): this;
prependOnceListener(event: "SIGTSTP", listener: () => void): this;
prependOnceListener(event: 'close', listener: () => void): this;
prependOnceListener(event: 'line', listener: (input: string) => void): this;
prependOnceListener(event: 'pause', listener: () => void): this;
prependOnceListener(event: 'resume', listener: () => void): this;
prependOnceListener(event: 'SIGCONT', listener: () => void): this;
prependOnceListener(event: 'SIGINT', listener: () => void): this;
prependOnceListener(event: 'SIGTSTP', listener: () => void): this;
prependOnceListener(event: 'history', listener: (history: string[]) => void): this;
[Symbol.asyncIterator](): AsyncIterableIterator<string>;
}
type ReadLine = Interface; // type forwarded for backwards compatibility
type Completer = (line: string) => CompleterResult;
type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => any;
type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
type CompleterResult = [string[], string];
interface ReadLineOptions {
input: NodeJS.ReadableStream;
output?: NodeJS.WritableStream | undefined;
completer?: Completer | AsyncCompleter | undefined;
terminal?: boolean | undefined;
/**
* Initial list of history lines. This option makes sense
* only if `terminal` is set to `true` by the user or by an internal `output`
* check, otherwise the history caching mechanism is not initialized at all.
* @default []
*/
history?: string[] | undefined;
historySize?: number | undefined;
prompt?: string | undefined;
crlfDelay?: number | undefined;
/**
* If `true`, when a new input line added
* to the history list duplicates an older one, this removes the older line
* from the list.
* @default false
*/
removeHistoryDuplicates?: boolean | undefined;
escapeCodeTimeout?: number | undefined;
tabSize?: number | undefined;
}
/**
* The `readline.createInterface()` method creates a new `readline.Interface`instance.
*
* ```js
* const readline = require('readline');
* const rl = readline.createInterface({
* input: process.stdin,
* output: process.stdout
* });
* ```
*
* Once the `readline.Interface` instance is created, the most common case is to
* listen for the `'line'` event:
*
* ```js
* rl.on('line', (line) => {
* console.log(`Received: ${line}`);
* });
* ```
*
* If `terminal` is `true` for this instance then the `output` stream will get
* the best compatibility if it defines an `output.columns` property and emits
* a `'resize'` event on the `output` if or when the columns ever change
* (`process.stdout` does this automatically when it is a TTY).
*
* When creating a `readline.Interface` using `stdin` as input, the program
* will not terminate until it receives `EOF` (Ctrl+D on
* Linux/macOS, Ctrl+Z followed by Return on
* Windows).
* If you want your application to exit without waiting for user input, you can `unref()` the standard input stream:
*
* ```js
* process.stdin.unref();
* ```
* @since v0.1.98
*/
function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
function createInterface(options: ReadLineOptions): Interface;
/**
* The `readline.emitKeypressEvents()` method causes the given `Readable` stream to begin emitting `'keypress'` events corresponding to received input.
*
* Optionally, `interface` specifies a `readline.Interface` instance for which
* autocompletion is disabled when copy-pasted input is detected.
*
* If the `stream` is a `TTY`, then it must be in raw mode.
*
* This is automatically called by any readline instance on its `input` if the`input` is a terminal. Closing the `readline` instance does not stop
* the `input` from emitting `'keypress'` events.
*
* ```js
* readline.emitKeypressEvents(process.stdin);
* if (process.stdin.isTTY)
* process.stdin.setRawMode(true);
* ```
* @since v0.7.7
*/
function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
type Direction = -1 | 0 | 1;
interface CursorPos {
rows: number;
cols: number;
}
/**
* Clears the current line of this WriteStream in a direction identified by `dir`.
* The `readline.clearLine()` method clears current line of given `TTY` stream
* in a specified direction identified by `dir`.
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
/**
* Clears this `WriteStream` from the current cursor down.
* The `readline.clearScreenDown()` method clears the given `TTY` stream from
* the current position of the cursor down.
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
/**
* Moves this WriteStream's cursor to the specified position.
* The `readline.cursorTo()` method moves cursor to the specified position in a
* given `TTY` `stream`.
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
/**
* Moves this WriteStream's cursor relative to its current position.
* The `readline.moveCursor()` method moves the cursor _relative_ to its current
* position in a given `TTY` `stream`.
*
* ## Example: Tiny CLI
*
* The following example illustrates the use of `readline.Interface` class to
* implement a small command-line interface:
*
* ```js
* const readline = require('readline');
* const rl = readline.createInterface({
* input: process.stdin,
* output: process.stdout,
* prompt: 'OHAI> '
* });
*
* rl.prompt();
*
* rl.on('line', (line) => {
* switch (line.trim()) {
* case 'hello':
* console.log('world!');
* break;
* default:
* console.log(`Say what? I might have heard '${line.trim()}'`);
* break;
* }
* rl.prompt();
* }).on('close', () => {
* console.log('Have a great day!');
* process.exit(0);
* });
* ```
*
* ## Example: Read file stream line-by-Line
*
* A common use case for `readline` is to consume an input file one line at a
* time. The easiest way to do so is leveraging the `fs.ReadStream` API as
* well as a `for await...of` loop:
*
* ```js
* const fs = require('fs');
* const readline = require('readline');
*
* async function processLineByLine() {
* const fileStream = fs.createReadStream('input.txt');
*
* const rl = readline.createInterface({
* input: fileStream,
* crlfDelay: Infinity
* });
* // Note: we use the crlfDelay option to recognize all instances of CR LF
* // ('\r\n') in input.txt as a single line break.
*
* for await (const line of rl) {
* // Each line in input.txt will be successively available here as `line`.
* console.log(`Line from file: ${line}`);
* }
* }
*
* processLineByLine();
* ```
*
* Alternatively, one could use the `'line'` event:
*
* ```js
* const fs = require('fs');
* const readline = require('readline');
*
* const rl = readline.createInterface({
* input: fs.createReadStream('sample.txt'),
* crlfDelay: Infinity
* });
*
* rl.on('line', (line) => {
* console.log(`Line from file: ${line}`);
* });
* ```
*
* Currently, `for await...of` loop can be a bit slower. If `async` / `await`flow and speed are both essential, a mixed approach can be applied:
*
* ```js
* const { once } = require('events');
* const { createReadStream } = require('fs');
* const { createInterface } = require('readline');
*
* (async function processLineByLine() {
* try {
* const rl = createInterface({
* input: createReadStream('big-file.txt'),
* crlfDelay: Infinity
* });
*
* rl.on('line', (line) => {
* // Process the line.
* });
*
* await once(rl, 'close');
*
* console.log('File processed.');
* } catch (err) {
* console.error(err);
* }
* })();
* ```
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
}

1258
packages/node_modules/@node-red/editor-client/src/types/node/stream.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

15
packages/node_modules/@node-red/editor-client/src/types/node/stream/consumers.d.ts vendored Normal file
View File

@ -0,0 +1,15 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
declare module 'stream/consumers' {
import { Readable } from 'node:stream';
import { Blob as NodeBlob } from "node:buffer";
function buffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Buffer>;
function text(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<string>;
function arrayBuffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<ArrayBuffer>;
function blob(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<NodeBlob>;
function json(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<unknown>;
}
declare module 'node:stream/consumers' {
export * from 'stream/consumers';
}

45
packages/node_modules/@node-red/editor-client/src/types/node/stream/promises.d.ts vendored Normal file
View File

@ -0,0 +1,45 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
declare module 'stream/promises' {
import { FinishedOptions, PipelineSource, PipelineTransform, PipelineDestination, PipelinePromise, PipelineOptions } from 'node:stream';
function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options?: FinishedOptions): Promise<void>;
function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(source: A, destination: B, options?: PipelineOptions): PipelinePromise<B>;
function pipeline<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, B extends PipelineDestination<T1, any>>(
source: A,
transform1: T1,
destination: B,
options?: PipelineOptions
): PipelinePromise<B>;
function pipeline<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, T2 extends PipelineTransform<T1, any>, B extends PipelineDestination<T2, any>>(
source: A,
transform1: T1,
transform2: T2,
destination: B,
options?: PipelineOptions
): PipelinePromise<B>;
function pipeline<
A extends PipelineSource<any>,
T1 extends PipelineTransform<A, any>,
T2 extends PipelineTransform<T1, any>,
T3 extends PipelineTransform<T2, any>,
B extends PipelineDestination<T3, any>
>(source: A, transform1: T1, transform2: T2, transform3: T3, destination: B, options?: PipelineOptions): PipelinePromise<B>;
function pipeline<
A extends PipelineSource<any>,
T1 extends PipelineTransform<A, any>,
T2 extends PipelineTransform<T1, any>,
T3 extends PipelineTransform<T2, any>,
T4 extends PipelineTransform<T3, any>,
B extends PipelineDestination<T4, any>
>(source: A, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: B, options?: PipelineOptions): PipelinePromise<B>;
function pipeline(streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>, options?: PipelineOptions): Promise<void>;
function pipeline(
stream1: NodeJS.ReadableStream,
stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
): Promise<void>;
}
declare module 'node:stream/promises' {
export * from 'stream/promises';
}

395
packages/node_modules/@node-red/editor-client/src/types/node/stream/web.d.ts vendored Normal file
View File

@ -0,0 +1,395 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
declare module 'stream/web' {
// stub module, pending copy&paste from .d.ts or manual impl
// copy from lib.dom.d.ts
interface ReadableWritablePair<R = any, W = any> {
readable: ReadableStream<R>;
/**
* Provides a convenient, chainable way of piping this readable stream
* through a transform stream (or any other { writable, readable }
* pair). It simply pipes the stream into the writable side of the
* supplied pair, and returns the readable side for further use.
*
* Piping a stream will lock it for the duration of the pipe, preventing
* any other consumer from acquiring a reader.
*/
writable: WritableStream<W>;
}
interface StreamPipeOptions {
preventAbort?: boolean;
preventCancel?: boolean;
/**
* Pipes this readable stream to a given writable stream destination.
* The way in which the piping process behaves under various error
* conditions can be customized with a number of passed options. It
* returns a promise that fulfills when the piping process completes
* successfully, or rejects if any errors were encountered.
*
* Piping a stream will lock it for the duration of the pipe, preventing
* any other consumer from acquiring a reader.
*
* Errors and closures of the source and destination streams propagate
* as follows:
*
* An error in this source readable stream will abort destination,
* unless preventAbort is truthy. The returned promise will be rejected
* with the source's error, or with any error that occurs during
* aborting the destination.
*
* An error in destination will cancel this source readable stream,
* unless preventCancel is truthy. The returned promise will be rejected
* with the destination's error, or with any error that occurs during
* canceling the source.
*
* When this source readable stream closes, destination will be closed,
* unless preventClose is truthy. The returned promise will be fulfilled
* once this process completes, unless an error is encountered while
* closing the destination, in which case it will be rejected with that
* error.
*
* If destination starts out closed or closing, this source readable
* stream will be canceled, unless preventCancel is true. The returned
* promise will be rejected with an error indicating piping to a closed
* stream failed, or with any error that occurs during canceling the
* source.
*
* The signal option can be set to an AbortSignal to allow aborting an
* ongoing pipe operation via the corresponding AbortController. In this
* case, this source readable stream will be canceled, and destination
* aborted, unless the respective options preventCancel or preventAbort
* are set.
*/
preventClose?: boolean;
signal?: AbortSignal;
}
interface ReadableStreamGenericReader {
readonly closed: Promise<undefined>;
cancel(reason?: any): Promise<void>;
}
interface ReadableStreamDefaultReadValueResult<T> {
done: false;
value: T;
}
interface ReadableStreamDefaultReadDoneResult {
done: true;
value?: undefined;
}
type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
type ReadableStreamDefaultReadResult<T> =
| ReadableStreamDefaultReadValueResult<T>
| ReadableStreamDefaultReadDoneResult;
interface ReadableByteStreamControllerCallback {
(controller: ReadableByteStreamController): void | PromiseLike<void>;
}
interface UnderlyingSinkAbortCallback {
(reason?: any): void | PromiseLike<void>;
}
interface UnderlyingSinkCloseCallback {
(): void | PromiseLike<void>;
}
interface UnderlyingSinkStartCallback {
(controller: WritableStreamDefaultController): any;
}
interface UnderlyingSinkWriteCallback<W> {
(chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
}
interface UnderlyingSourceCancelCallback {
(reason?: any): void | PromiseLike<void>;
}
interface UnderlyingSourcePullCallback<R> {
(controller: ReadableStreamController<R>): void | PromiseLike<void>;
}
interface UnderlyingSourceStartCallback<R> {
(controller: ReadableStreamController<R>): any;
}
interface TransformerFlushCallback<O> {
(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
}
interface TransformerStartCallback<O> {
(controller: TransformStreamDefaultController<O>): any;
}
interface TransformerTransformCallback<I, O> {
(chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
}
interface UnderlyingByteSource {
autoAllocateChunkSize?: number;
cancel?: ReadableStreamErrorCallback;
pull?: ReadableByteStreamControllerCallback;
start?: ReadableByteStreamControllerCallback;
type: 'bytes';
}
interface UnderlyingSource<R = any> {
cancel?: UnderlyingSourceCancelCallback;
pull?: UnderlyingSourcePullCallback<R>;
start?: UnderlyingSourceStartCallback<R>;
type?: undefined;
}
interface UnderlyingSink<W = any> {
abort?: UnderlyingSinkAbortCallback;
close?: UnderlyingSinkCloseCallback;
start?: UnderlyingSinkStartCallback;
type?: undefined;
write?: UnderlyingSinkWriteCallback<W>;
}
interface ReadableStreamErrorCallback {
(reason: any): void | PromiseLike<void>;
}
/** This Streams API interface represents a readable stream of byte data. */
interface ReadableStream<R = any> {
readonly locked: boolean;
cancel(reason?: any): Promise<void>;
getReader(): ReadableStreamDefaultReader<R>;
pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
tee(): [ReadableStream<R>, ReadableStream<R>];
values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
[Symbol.asyncIterator](): AsyncIterableIterator<R>;
}
const ReadableStream: {
prototype: ReadableStream;
new (
underlyingSource: UnderlyingByteSource,
strategy?: QueuingStrategy<Uint8Array>,
): ReadableStream<Uint8Array>;
new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
};
interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
read(): Promise<ReadableStreamDefaultReadResult<R>>;
releaseLock(): void;
}
const ReadableStreamDefaultReader: {
prototype: ReadableStreamDefaultReader;
new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
};
const ReadableStreamBYOBReader: any;
const ReadableStreamBYOBRequest: any;
interface ReadableByteStreamController {
readonly byobRequest: undefined;
readonly desiredSize: number | null;
close(): void;
enqueue(chunk: ArrayBufferView): void;
error(error?: any): void;
}
const ReadableByteStreamController: {
prototype: ReadableByteStreamController;
new (): ReadableByteStreamController;
};
interface ReadableStreamDefaultController<R = any> {
readonly desiredSize: number | null;
close(): void;
enqueue(chunk?: R): void;
error(e?: any): void;
}
const ReadableStreamDefaultController: {
prototype: ReadableStreamDefaultController;
new (): ReadableStreamDefaultController;
};
interface Transformer<I = any, O = any> {
flush?: TransformerFlushCallback<O>;
readableType?: undefined;
start?: TransformerStartCallback<O>;
transform?: TransformerTransformCallback<I, O>;
writableType?: undefined;
}
interface TransformStream<I = any, O = any> {
readonly readable: ReadableStream<O>;
readonly writable: WritableStream<I>;
}
const TransformStream: {
prototype: TransformStream;
new <I = any, O = any>(
transformer?: Transformer<I, O>,
writableStrategy?: QueuingStrategy<I>,
readableStrategy?: QueuingStrategy<O>,
): TransformStream<I, O>;
};
interface TransformStreamDefaultController<O = any> {
readonly desiredSize: number | null;
enqueue(chunk?: O): void;
error(reason?: any): void;
terminate(): void;
}
const TransformStreamDefaultController: {
prototype: TransformStreamDefaultController;
new (): TransformStreamDefaultController;
};
/**
* This Streams API interface provides a standard abstraction for writing
* streaming data to a destination, known as a sink. This object comes with
* built-in back pressure and queuing.
*/
interface WritableStream<W = any> {
readonly locked: boolean;
abort(reason?: any): Promise<void>;
close(): Promise<void>;
getWriter(): WritableStreamDefaultWriter<W>;
}
const WritableStream: {
prototype: WritableStream;
new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
};
/**
* This Streams API interface is the object returned by
* WritableStream.getWriter() and once created locks the < writer to the
* WritableStream ensuring that no other streams can write to the underlying
* sink.
*/
interface WritableStreamDefaultWriter<W = any> {
readonly closed: Promise<undefined>;
readonly desiredSize: number | null;
readonly ready: Promise<undefined>;
abort(reason?: any): Promise<void>;
close(): Promise<void>;
releaseLock(): void;
write(chunk?: W): Promise<void>;
}
const WritableStreamDefaultWriter: {
prototype: WritableStreamDefaultWriter;
new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
};
/**
* This Streams API interface represents a controller allowing control of a
* WritableStream's state. When constructing a WritableStream, the
* underlying sink is given a corresponding WritableStreamDefaultController
* instance to manipulate.
*/
interface WritableStreamDefaultController {
error(e?: any): void;
}
const WritableStreamDefaultController: {
prototype: WritableStreamDefaultController;
new (): WritableStreamDefaultController;
};
interface QueuingStrategy<T = any> {
highWaterMark?: number;
size?: QueuingStrategySize<T>;
}
interface QueuingStrategySize<T = any> {
(chunk?: T): number;
}
interface QueuingStrategyInit {
/**
* Creates a new ByteLengthQueuingStrategy with the provided high water
* mark.
*
* Note that the provided high water mark will not be validated ahead of
* time. Instead, if it is negative, NaN, or not a number, the resulting
* ByteLengthQueuingStrategy will cause the corresponding stream
* constructor to throw.
*/
highWaterMark: number;
}
/**
* This Streams API interface provides a built-in byte length queuing
* strategy that can be used when constructing streams.
*/
interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
readonly highWaterMark: number;
readonly size: QueuingStrategySize<ArrayBufferView>;
}
const ByteLengthQueuingStrategy: {
prototype: ByteLengthQueuingStrategy;
new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
};
/**
* This Streams API interface provides a built-in byte length queuing
* strategy that can be used when constructing streams.
*/
interface CountQueuingStrategy extends QueuingStrategy {
readonly highWaterMark: number;
readonly size: QueuingStrategySize;
}
const CountQueuingStrategy: {
prototype: CountQueuingStrategy;
new (init: QueuingStrategyInit): CountQueuingStrategy;
};
interface TextEncoderStream {
/** Returns "utf-8". */
readonly encoding: 'utf-8';
readonly readable: ReadableStream<Uint8Array>;
readonly writable: WritableStream<string>;
readonly [Symbol.toStringTag]: string;
}
const TextEncoderStream: {
prototype: TextEncoderStream;
new (): TextEncoderStream;
};
interface TextDecoderOptions {
fatal?: boolean;
ignoreBOM?: boolean;
}
type BufferSource = ArrayBufferView | ArrayBuffer;
interface TextDecoderStream {
/** Returns encoding's name, lower cased. */
readonly encoding: string;
/** Returns `true` if error mode is "fatal", and `false` otherwise. */
readonly fatal: boolean;
/** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
readonly ignoreBOM: boolean;
readonly readable: ReadableStream<string>;
readonly writable: WritableStream<BufferSource>;
readonly [Symbol.toStringTag]: string;
}
const TextDecoderStream: {
prototype: TextDecoderStream;
new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
};
}
declare module 'node:stream/web' {
export * from 'stream/web';
}

57
packages/node_modules/@node-red/editor-client/src/types/node/string_decoder.d.ts vendored
View File

@ -1,10 +1,67 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `string_decoder` module provides an API for decoding `Buffer` objects into
* strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
* characters. It can be accessed using:
*
* ```js
* const { StringDecoder } = require('string_decoder');
* ```
*
* The following example shows the basic use of the `StringDecoder` class.
*
* ```js
* const { StringDecoder } = require('string_decoder');
* const decoder = new StringDecoder('utf8');
*
* const cent = Buffer.from([0xC2, 0xA2]);
* console.log(decoder.write(cent));
*
* const euro = Buffer.from([0xE2, 0x82, 0xAC]);
* console.log(decoder.write(euro));
* ```
*
* When a `Buffer` instance is written to the `StringDecoder` instance, an
* internal buffer is used to ensure that the decoded string does not contain
* any incomplete multibyte characters. These are held in the buffer until the
* next call to `stringDecoder.write()` or until `stringDecoder.end()` is called.
*
* In the following example, the three UTF-8 encoded bytes of the European Euro
* symbol (`€`) are written over three separate operations:
*
* ```js
* const { StringDecoder } = require('string_decoder');
* const decoder = new StringDecoder('utf8');
*
* decoder.write(Buffer.from([0xE2]));
* decoder.write(Buffer.from([0x82]));
* console.log(decoder.end(Buffer.from([0xAC])));
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/string_decoder.js)
*/
declare module 'string_decoder' {
class StringDecoder {
constructor(encoding?: BufferEncoding);
/**
* Returns a decoded string, ensuring that any incomplete multibyte characters at
* the end of the `Buffer`, or `TypedArray`, or `DataView` are omitted from the
* returned string and stored in an internal buffer for the next call to`stringDecoder.write()` or `stringDecoder.end()`.
* @since v0.1.99
* @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
*/
write(buffer: Buffer): string;
/**
* Returns any remaining input stored in the internal buffer as a string. Bytes
* representing incomplete UTF-8 and UTF-16 characters will be replaced with
* substitution characters appropriate for the character encoding.
*
* If the `buffer` argument is provided, one final call to `stringDecoder.write()`is performed before returning the remaining input.
* After `end()` is called, the `stringDecoder` object can be reused for new input.
* @since v0.9.3
* @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
*/
end(buffer?: Buffer): string;
}
}

193
packages/node_modules/@node-red/editor-client/src/types/node/test.d.ts vendored Normal file
View File

@ -0,0 +1,193 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `node:test` module provides a standalone testing module.
* @see [source](https://github.com/nodejs/node/blob/v16.17.0/lib/test.js)
*/
declare module 'node:test' {
/**
* The `test()` function is the value imported from the test module. Each invocation of this
* function results in the creation of a test point in the TAP output.
*
* The {@link TestContext} object passed to the fn argument can be used to perform actions
* related to the current test. Examples include skipping the test, adding additional TAP
* diagnostic information, or creating subtests.
*
* `test()` returns a {@link Promise} that resolves once the test completes. The return value
* can usually be discarded for top level tests. However, the return value from subtests should
* be used to prevent the parent test from finishing first and cancelling the subtest as shown
* in the following example.
*
* ```js
* test('top level test', async (t) => {
* // The setTimeout() in the following subtest would cause it to outlive its
* // parent test if 'await' is removed on the next line. Once the parent test
* // completes, it will cancel any outstanding subtests.
* await t.test('longer running subtest', async (t) => {
* return new Promise((resolve, reject) => {
* setTimeout(resolve, 1000);
* });
* });
* });
* ```
* @since v16.17.0
* @param name The name of the test, which is displayed when reporting test results.
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
* @param options Configuration options for the test
* @param fn The function under test. The first argument to this function is a
* {@link TestContext} object. If the test uses callbacks, the callback function is
* passed as the second argument. Default: A no-op function.
* @returns A {@link Promise} resolved with `undefined` once the test completes.
*/
function test(name?: string, fn?: TestFn): Promise<void>;
function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
function test(options?: TestOptions, fn?: TestFn): Promise<void>;
function test(fn?: TestFn): Promise<void>;
/**
* @since v16.17.0
* @param name The name of the suite, which is displayed when reporting suite results.
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
* @param options Configuration options for the suite
* @param fn The function under suite. Default: A no-op function.
*/
function describe(name?: string, options?: TestOptions, fn?: SuiteFn): void;
function describe(name?: string, fn?: SuiteFn): void;
function describe(options?: TestOptions, fn?: SuiteFn): void;
function describe(fn?: SuiteFn): void;
/**
* @since v16.17.0
* @param name The name of the test, which is displayed when reporting test results.
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
* @param options Configuration options for the test
* @param fn The function under test. If the test uses callbacks, the callback function is
* passed as the second argument. Default: A no-op function.
*/
function it(name?: string, options?: TestOptions, fn?: ItFn): void;
function it(name?: string, fn?: ItFn): void;
function it(options?: TestOptions, fn?: ItFn): void;
function it(fn?: ItFn): void;
/**
* The type of a function under test. The first argument to this function is a
* {@link TestContext} object. If the test uses callbacks, the callback function is passed as
* the second argument.
*/
type TestFn = (t: TestContext, done: (result?: any) => void) => any;
/**
* The type of a function under Suite.
* If the test uses callbacks, the callback function is passed as an argument
*/
type SuiteFn = (done: (result?: any) => void) => void;
/**
* The type of a function under test.
* If the test uses callbacks, the callback function is passed as an argument
*/
type ItFn = (done: (result?: any) => void) => any;
/**
* An instance of `TestContext` is passed to each test function in order to interact with the
* test runner. However, the `TestContext` constructor is not exposed as part of the API.
* @since v16.17.0
*/
interface TestContext {
/**
* This function is used to write TAP diagnostics to the output. Any diagnostic information is
* included at the end of the test's results. This function does not return a value.
* @param message Message to be displayed as a TAP diagnostic.
* @since v16.17.0
*/
diagnostic(message: string): void;
/**
* If `shouldRunOnlyTests` is truthy, the test context will only run tests that have the `only`
* option set. Otherwise, all tests are run. If Node.js was not started with the `--test-only`
* command-line option, this function is a no-op.
* @param shouldRunOnlyTests Whether or not to run `only` tests.
* @since v16.17.0
*/
runOnly(shouldRunOnlyTests: boolean): void;
/**
* This function causes the test's output to indicate the test as skipped. If `message` is
* provided, it is included in the TAP output. Calling `skip()` does not terminate execution of
* the test function. This function does not return a value.
* @param message Optional skip message to be displayed in TAP output.
* @since v16.17.0
*/
skip(message?: string): void;
/**
* This function adds a `TODO` directive to the test's output. If `message` is provided, it is
* included in the TAP output. Calling `todo()` does not terminate execution of the test
* function. This function does not return a value.
* @param message Optional `TODO` message to be displayed in TAP output.
* @since v16.17.0
*/
todo(message?: string): void;
/**
* This function is used to create subtests under the current test. This function behaves in
* the same fashion as the top level {@link test} function.
* @since v16.17.0
* @param name The name of the test, which is displayed when reporting test results.
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
* @param options Configuration options for the test
* @param fn The function under test. This first argument to this function is a
* {@link TestContext} object. If the test uses callbacks, the callback function is
* passed as the second argument. Default: A no-op function.
* @returns A {@link Promise} resolved with `undefined` once the test completes.
*/
test: typeof test;
}
interface TestOptions {
/**
* The number of tests that can be run at the same time. If unspecified, subtests inherit this
* value from their parent.
* @default 1
*/
concurrency?: number;
/**
* If truthy, and the test context is configured to run `only` tests, then this test will be
* run. Otherwise, the test is skipped.
* @default false
*/
only?: boolean;
/**
* Allows aborting an in-progress test.
* @since v16.17.0
*/
signal?: AbortSignal;
/**
* If truthy, the test is skipped. If a string is provided, that string is displayed in the
* test results as the reason for skipping the test.
* @default false
*/
skip?: boolean | string;
/**
* A number of milliseconds the test will fail after. If unspecified, subtests inherit this
* value from their parent.
* @default Infinity
* @since v16.17.0
*/
timeout?: number;
/**
* If truthy, the test marked as `TODO`. If a string is provided, that string is displayed in
* the test results as the reason why the test is `TODO`.
* @default false
*/
todo?: boolean | string;
}
export { test as default, test, describe, it };
}

99
packages/node_modules/@node-red/editor-client/src/types/node/timers.d.ts vendored
View File

@ -1,21 +1,96 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `timer` module exposes a global API for scheduling functions to
* be called at some future period of time. Because the timer functions are
* globals, there is no need to call `require('timers')` to use the API.
*
* The timer functions within Node.js implement a similar API as the timers API
* provided by Web Browsers but use a different internal implementation that is
* built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/timers.js)
*/
declare module 'timers' {
function setTimeout(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
namespace setTimeout {
function __promisify__(ms: number): Promise<void>;
function __promisify__<T>(ms: number, value: T): Promise<T>;
import { Abortable } from 'node:events';
import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'node:timers/promises';
interface TimerOptions extends Abortable {
/**
* Set to `false` to indicate that the scheduled `Timeout`
* should not require the Node.js event loop to remain active.
* @default true
*/
ref?: boolean | undefined;
}
function clearTimeout(timeoutId: NodeJS.Timeout): void;
function setInterval(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;
function clearInterval(intervalId: NodeJS.Timeout): void;
function setImmediate(callback: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate;
namespace setImmediate {
function __promisify__(): Promise<void>;
function __promisify__<T>(value: T): Promise<T>;
let setTimeout: typeof global.setTimeout;
let clearTimeout: typeof global.clearTimeout;
let setInterval: typeof global.setInterval;
let clearInterval: typeof global.clearInterval;
let setImmediate: typeof global.setImmediate;
let clearImmediate: typeof global.clearImmediate;
global {
namespace NodeJS {
// compatibility with older typings
interface Timer extends RefCounted {
hasRef(): boolean;
refresh(): this;
[Symbol.toPrimitive](): number;
}
interface Immediate extends RefCounted {
/**
* If true, the `Immediate` object will keep the Node.js event loop active.
* @since v11.0.0
*/
hasRef(): boolean;
_onImmediate: Function; // to distinguish it from the Timeout class
}
interface Timeout extends Timer {
/**
* If true, the `Timeout` object will keep the Node.js event loop active.
* @since v11.0.0
*/
hasRef(): boolean;
/**
* Sets the timer's start time to the current time, and reschedules the timer to
* call its callback at the previously specified duration adjusted to the current
* time. This is useful for refreshing a timer without allocating a new
* JavaScript object.
*
* Using this on a timer that has already called its callback will reactivate the
* timer.
* @since v10.2.0
* @return a reference to `timeout`
*/
refresh(): this;
[Symbol.toPrimitive](): number;
}
}
function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
function setTimeout(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
namespace setTimeout {
const __promisify__: typeof setTimeoutPromise;
}
function clearTimeout(timeoutId: NodeJS.Timeout | string | number | undefined): void;
function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
namespace setInterval {
const __promisify__: typeof setIntervalPromise;
}
function clearInterval(intervalId: NodeJS.Timeout | string | number | undefined): void;
function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
function setImmediate(callback: (args: void) => void): NodeJS.Immediate;
namespace setImmediate {
const __promisify__: typeof setImmediatePromise;
}
function clearImmediate(immediateId: NodeJS.Immediate | undefined): void;
function queueMicrotask(callback: () => void): void;
}
function clearImmediate(immediateId: NodeJS.Immediate): void;
}
declare module 'node:timers' {
export * from 'timers';

96
packages/node_modules/@node-red/editor-client/src/types/node/timers/promises.d.ts vendored Normal file
View File

@ -0,0 +1,96 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `timers/promises` API provides an alternative set of timer functions
* that return `Promise` objects. The API is accessible via`require('timers/promises')`.
*
* ```js
* import {
* setTimeout,
* setImmediate,
* setInterval,
* } from 'timers/promises';
* ```
* @since v15.0.0
*/
declare module 'timers/promises' {
import { TimerOptions } from 'node:timers';
/**
* ```js
* import {
* setTimeout,
* } from 'timers/promises';
*
* const res = await setTimeout(100, 'result');
*
* console.log(res); // Prints 'result'
* ```
* @since v15.0.0
* @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
* @param value A value with which the promise is fulfilled.
*/
function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
/**
* ```js
* import {
* setImmediate,
* } from 'timers/promises';
*
* const res = await setImmediate('result');
*
* console.log(res); // Prints 'result'
* ```
* @since v15.0.0
* @param value A value with which the promise is fulfilled.
*/
function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
/**
* Returns an async iterator that generates values in an interval of `delay` ms.
*
* ```js
* import {
* setInterval,
* } from 'timers/promises';
*
* const interval = 100;
* for await (const startTime of setInterval(interval, Date.now())) {
* const now = Date.now();
* console.log(now);
* if ((now - startTime) > 1000)
* break;
* }
* console.log(Date.now());
* ```
* @since v15.9.0
*/
function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
interface Scheduler {
/**
* ```js
* import { scheduler } from 'node:timers/promises';
*
* await scheduler.wait(1000); // Wait one second before continuing
* ```
* An experimental API defined by the Scheduling APIs draft specification being developed as a standard Web Platform API.
* Calling timersPromises.scheduler.wait(delay, options) is roughly equivalent to calling timersPromises.setTimeout(delay, undefined, options) except that the ref option is not supported.
* @since v16.14.0
* @experimental
* @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
*/
wait: (delay?: number, options?: TimerOptions) => Promise<void>;
/**
* An experimental API defined by the Scheduling APIs draft specification being developed as a standard Web Platform API.
* Calling timersPromises.scheduler.yield() is equivalent to calling timersPromises.setImmediate() with no arguments.
* @since v16.14.0
* @experimental
*/
yield: () => Promise<void>;
}
const scheduler: Scheduler;
}
declare module 'node:timers/promises' {
export * from 'timers/promises';
}

675
packages/node_modules/@node-red/editor-client/src/types/node/tls.d.ts vendored
View File

@ -1,13 +1,21 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `tls` module provides an implementation of the Transport Layer Security
* (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.
* The module can be accessed using:
*
* ```js
* const tls = require('tls');
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/tls.js)
*/
declare module 'tls' {
import * as net from 'net';
import * as stream from 'stream';
import { X509Certificate } from 'node:crypto';
import * as net from 'node:net';
const CLIENT_RENEG_LIMIT: number;
const CLIENT_RENEG_WINDOW: number;
interface Certificate {
/**
* Country code.
@ -34,7 +42,6 @@ declare module 'tls' {
*/
CN: string;
}
interface PeerCertificate {
subject: Certificate;
issuer: Certificate;
@ -50,11 +57,9 @@ declare module 'tls' {
serialNumber: string;
raw: Buffer;
}
interface DetailedPeerCertificate extends PeerCertificate {
issuerCertificate: DetailedPeerCertificate;
}
interface CipherNameAndProtocol {
/**
* The cipher name.
@ -64,13 +69,11 @@ declare module 'tls' {
* SSL/TLS protocol version.
*/
version: string;
/**
* IETF name for the cipher suite.
*/
standardName: string;
}
interface EphemeralKeyInfo {
/**
* The supported types are 'DH' and 'ECDH'.
@ -85,7 +88,6 @@ declare module 'tls' {
*/
size: number;
}
interface KeyObject {
/**
* Private keys in PEM format.
@ -96,7 +98,6 @@ declare module 'tls' {
*/
passphrase?: string | undefined;
}
interface PxfObject {
/**
* PFX or PKCS12 encoded private key and certificate chain.
@ -107,7 +108,6 @@ declare module 'tls' {
*/
passphrase?: string | undefined;
}
interface TLSSocketOptions extends SecureContextOptions, CommonConnectionOptions {
/**
* If true the TLS socket will be instantiated in server-mode.
@ -118,7 +118,6 @@ declare module 'tls' {
* An optional net.Server instance.
*/
server?: net.Server | undefined;
/**
* An optional Buffer instance containing a TLS session.
*/
@ -130,227 +129,307 @@ declare module 'tls' {
*/
requestOCSP?: boolean | undefined;
}
/**
* Performs transparent encryption of written data and all required TLS
* negotiation.
*
* Instances of `tls.TLSSocket` implement the duplex `Stream` interface.
*
* Methods that return TLS connection metadata (e.g.{@link TLSSocket.getPeerCertificate} will only return data while the
* connection is open.
* @since v0.11.4
*/
class TLSSocket extends net.Socket {
/**
* Construct a new tls.TLSSocket object from an existing TCP socket.
*/
constructor(socket: net.Socket, options?: TLSSocketOptions);
/**
* A boolean that is true if the peer certificate was signed by one of the specified CAs, otherwise false.
* Returns `true` if the peer certificate was signed by one of the CAs specified
* when creating the `tls.TLSSocket` instance, otherwise `false`.
* @since v0.11.4
*/
authorized: boolean;
/**
* The reason why the peer's certificate has not been verified.
* This property becomes available only when tlsSocket.authorized === false.
* Returns the reason why the peer's certificate was not been verified. This
* property is set only when `tlsSocket.authorized === false`.
* @since v0.11.4
*/
authorizationError: Error;
/**
* Static boolean value, always true.
* May be used to distinguish TLS sockets from regular ones.
* Always returns `true`. This may be used to distinguish TLS sockets from regular`net.Socket` instances.
* @since v0.11.4
*/
encrypted: boolean;
encrypted: true;
/**
* String containing the selected ALPN protocol.
* Before a handshake has completed, this value is always null.
* When a handshake is completed but not ALPN protocol was selected, tlsSocket.alpnProtocol equals false.
*/
alpnProtocol: string | false | null;
/**
* Returns an object representing the local certificate. The returned
* object has some properties corresponding to the fields of the
* certificate.
* Returns an object representing the local certificate. The returned object has
* some properties corresponding to the fields of the certificate.
*
* See tls.TLSSocket.getPeerCertificate() for an example of the
* certificate structure.
* See {@link TLSSocket.getPeerCertificate} for an example of the certificate
* structure.
*
* If there is no local certificate, an empty object will be returned.
* If the socket has been destroyed, null will be returned.
* If there is no local certificate, an empty object will be returned. If the
* socket has been destroyed, `null` will be returned.
* @since v11.2.0
*/
getCertificate(): PeerCertificate | object | null;
/**
* Returns an object representing the cipher name and the SSL/TLS protocol version of the current connection.
* @returns Returns an object representing the cipher name
* and the SSL/TLS protocol version of the current connection.
* Returns an object containing information on the negotiated cipher suite.
*
* For example:
*
* ```json
* {
* "name": "AES128-SHA256",
* "standardName": "TLS_RSA_WITH_AES_128_CBC_SHA256",
* "version": "TLSv1.2"
* }
* ```
*
* See [SSL\_CIPHER\_get\_name](https://www.openssl.org/docs/man1.1.1/man3/SSL_CIPHER_get_name.html) for more information.
* @since v0.11.4
*/
getCipher(): CipherNameAndProtocol;
/**
* Returns an object representing the type, name, and size of parameter
* of an ephemeral key exchange in Perfect Forward Secrecy on a client
* Returns an object representing the type, name, and size of parameter of
* an ephemeral key exchange in `perfect forward secrecy` on a client
* connection. It returns an empty object when the key exchange is not
* ephemeral. As this is only supported on a client socket; null is
* returned if called on a server socket. The supported types are 'DH'
* and 'ECDH'. The name property is available only when type is 'ECDH'.
* ephemeral. As this is only supported on a client socket; `null` is returned
* if called on a server socket. The supported types are `'DH'` and `'ECDH'`. The`name` property is available only when type is `'ECDH'`.
*
* For example: { type: 'ECDH', name: 'prime256v1', size: 256 }.
* For example: `{ type: 'ECDH', name: 'prime256v1', size: 256 }`.
* @since v5.0.0
*/
getEphemeralKeyInfo(): EphemeralKeyInfo | object | null;
/**
* Returns the latest Finished message that has
* been sent to the socket as part of a SSL/TLS handshake, or undefined
* if no Finished message has been sent yet.
* As the `Finished` messages are message digests of the complete handshake
* (with a total of 192 bits for TLS 1.0 and more for SSL 3.0), they can
* be used for external authentication procedures when the authentication
* provided by SSL/TLS is not desired or is not enough.
*
* As the Finished messages are message digests of the complete
* handshake (with a total of 192 bits for TLS 1.0 and more for SSL
* 3.0), they can be used for external authentication procedures when
* the authentication provided by SSL/TLS is not desired or is not
* enough.
*
* Corresponds to the SSL_get_finished routine in OpenSSL and may be
* used to implement the tls-unique channel binding from RFC 5929.
* Corresponds to the `SSL_get_finished` routine in OpenSSL and may be used
* to implement the `tls-unique` channel binding from [RFC 5929](https://tools.ietf.org/html/rfc5929).
* @since v9.9.0
* @return The latest `Finished` message that has been sent to the socket as part of a SSL/TLS handshake, or `undefined` if no `Finished` message has been sent yet.
*/
getFinished(): Buffer | undefined;
/**
* Returns an object representing the peer's certificate.
* The returned object has some properties corresponding to the field of the certificate.
* If detailed argument is true the full chain with issuer property will be returned,
* if false only the top certificate without issuer property.
* If the peer does not provide a certificate, it returns null or an empty object.
* @param detailed - If true; the full chain with issuer property will be returned.
* @returns An object representing the peer's certificate.
* Returns an object representing the peer's certificate. If the peer does not
* provide a certificate, an empty object will be returned. If the socket has been
* destroyed, `null` will be returned.
*
* If the full certificate chain was requested, each certificate will include an`issuerCertificate` property containing an object representing its issuer's
* certificate.
* @since v0.11.4
* @param detailed Include the full certificate chain if `true`, otherwise include just the peer's certificate.
* @return A certificate object.
*/
getPeerCertificate(detailed: true): DetailedPeerCertificate;
getPeerCertificate(detailed?: false): PeerCertificate;
getPeerCertificate(detailed?: boolean): PeerCertificate | DetailedPeerCertificate;
/**
* Returns the latest Finished message that is expected or has actually
* been received from the socket as part of a SSL/TLS handshake, or
* undefined if there is no Finished message so far.
* As the `Finished` messages are message digests of the complete handshake
* (with a total of 192 bits for TLS 1.0 and more for SSL 3.0), they can
* be used for external authentication procedures when the authentication
* provided by SSL/TLS is not desired or is not enough.
*
* As the Finished messages are message digests of the complete
* handshake (with a total of 192 bits for TLS 1.0 and more for SSL
* 3.0), they can be used for external authentication procedures when
* the authentication provided by SSL/TLS is not desired or is not
* enough.
*
* Corresponds to the SSL_get_peer_finished routine in OpenSSL and may
* be used to implement the tls-unique channel binding from RFC 5929.
* Corresponds to the `SSL_get_peer_finished` routine in OpenSSL and may be used
* to implement the `tls-unique` channel binding from [RFC 5929](https://tools.ietf.org/html/rfc5929).
* @since v9.9.0
* @return The latest `Finished` message that is expected or has actually been received from the socket as part of a SSL/TLS handshake, or `undefined` if there is no `Finished` message so
* far.
*/
getPeerFinished(): Buffer | undefined;
/**
* Returns a string containing the negotiated SSL/TLS protocol version of the current connection.
* The value `'unknown'` will be returned for connected sockets that have not completed the handshaking process.
* The value `null` will be returned for server sockets or disconnected client sockets.
* See https://www.openssl.org/docs/man1.0.2/ssl/SSL_get_version.html for more information.
* @returns negotiated SSL/TLS protocol version of the current connection
* Returns a string containing the negotiated SSL/TLS protocol version of the
* current connection. The value `'unknown'` will be returned for connected
* sockets that have not completed the handshaking process. The value `null` will
* be returned for server sockets or disconnected client sockets.
*
* Protocol versions are:
*
* * `'SSLv3'`
* * `'TLSv1'`
* * `'TLSv1.1'`
* * `'TLSv1.2'`
* * `'TLSv1.3'`
*
* See the OpenSSL [`SSL_get_version`](https://www.openssl.org/docs/man1.1.1/man3/SSL_get_version.html) documentation for more information.
* @since v5.7.0
*/
getProtocol(): string | null;
/**
* Could be used to speed up handshake establishment when reconnecting to the server.
* @returns ASN.1 encoded TLS session or undefined if none was negotiated.
* Returns the TLS session data or `undefined` if no session was
* negotiated. On the client, the data can be provided to the `session` option of {@link connect} to resume the connection. On the server, it may be useful
* for debugging.
*
* See `Session Resumption` for more information.
*
* Note: `getSession()` works only for TLSv1.2 and below. For TLSv1.3, applications
* must use the `'session'` event (it also works for TLSv1.2 and below).
* @since v0.11.4
*/
getSession(): Buffer | undefined;
/**
* Returns a list of signature algorithms shared between the server and
* the client in the order of decreasing preference.
* See [SSL\_get\_shared\_sigalgs](https://www.openssl.org/docs/man1.1.1/man3/SSL_get_shared_sigalgs.html) for more information.
* @since v12.11.0
* @return List of signature algorithms shared between the server and the client in the order of decreasing preference.
*/
getSharedSigalgs(): string[];
/**
* NOTE: Works only with client TLS sockets.
* Useful only for debugging, for session reuse provide session option to tls.connect().
* @returns TLS session ticket or undefined if none was negotiated.
* For a client, returns the TLS session ticket if one is available, or`undefined`. For a server, always returns `undefined`.
*
* It may be useful for debugging.
*
* See `Session Resumption` for more information.
* @since v0.11.4
*/
getTLSTicket(): Buffer | undefined;
/**
* Returns true if the session was reused, false otherwise.
* See `Session Resumption` for more information.
* @since v0.5.6
* @return `true` if the session was reused, `false` otherwise.
*/
isSessionReused(): boolean;
/**
* Initiate TLS renegotiation process.
* The `tlsSocket.renegotiate()` method initiates a TLS renegotiation process.
* Upon completion, the `callback` function will be passed a single argument
* that is either an `Error` (if the request failed) or `null`.
*
* NOTE: Can be used to request peer's certificate after the secure connection has been established.
* ANOTHER NOTE: When running as the server, socket will be destroyed with an error after handshakeTimeout timeout.
* @param options - The options may contain the following fields: rejectUnauthorized,
* requestCert (See tls.createServer() for details).
* @param callback - callback(err) will be executed with null as err, once the renegotiation
* is successfully completed.
* @return `undefined` when socket is destroy, `false` if negotiaion can't be initiated.
* This method can be used to request a peer's certificate after the secure
* connection has been established.
*
* When running as the server, the socket will be destroyed with an error after`handshakeTimeout` timeout.
*
* For TLSv1.3, renegotiation cannot be initiated, it is not supported by the
* protocol.
* @since v0.11.8
* @param callback If `renegotiate()` returned `true`, callback is attached once to the `'secure'` event. If `renegotiate()` returned `false`, `callback` will be called in the next tick with
* an error, unless the `tlsSocket` has been destroyed, in which case `callback` will not be called at all.
* @return `true` if renegotiation was initiated, `false` otherwise.
*/
renegotiate(options: { rejectUnauthorized?: boolean | undefined, requestCert?: boolean | undefined }, callback: (err: Error | null) => void): undefined | boolean;
renegotiate(
options: {
rejectUnauthorized?: boolean | undefined;
requestCert?: boolean | undefined;
},
callback: (err: Error | null) => void
): undefined | boolean;
/**
* Set maximum TLS fragment size (default and maximum value is: 16384, minimum is: 512).
* Smaller fragment size decreases buffering latency on the client: large fragments are buffered by
* the TLS layer until the entire fragment is received and its integrity is verified;
* large fragments can span multiple roundtrips, and their processing can be delayed due to packet
* loss or reordering. However, smaller fragments add extra TLS framing bytes and CPU overhead,
* which may decrease overall server throughput.
* @param size - TLS fragment size (default and maximum value is: 16384, minimum is: 512).
* @returns Returns true on success, false otherwise.
* The `tlsSocket.setMaxSendFragment()` method sets the maximum TLS fragment size.
* Returns `true` if setting the limit succeeded; `false` otherwise.
*
* Smaller fragment sizes decrease the buffering latency on the client: larger
* fragments are buffered by the TLS layer until the entire fragment is received
* and its integrity is verified; large fragments can span multiple roundtrips
* and their processing can be delayed due to packet loss or reordering. However,
* smaller fragments add extra TLS framing bytes and CPU overhead, which may
* decrease overall server throughput.
* @since v0.11.11
* @param [size=16384] The maximum TLS fragment size. The maximum value is `16384`.
*/
setMaxSendFragment(size: number): boolean;
/**
* Disables TLS renegotiation for this TLSSocket instance. Once called,
* attempts to renegotiate will trigger an 'error' event on the
* TLSSocket.
* Disables TLS renegotiation for this `TLSSocket` instance. Once called, attempts
* to renegotiate will trigger an `'error'` event on the `TLSSocket`.
* @since v8.4.0
*/
disableRenegotiation(): void;
/**
* When enabled, TLS packet trace information is written to `stderr`. This can be
* used to debug TLS connection problems.
*
* Note: The format of the output is identical to the output of `openssl s_client
* -trace` or `openssl s_server -trace`. While it is produced by OpenSSL's
* `SSL_trace()` function, the format is undocumented, can change without notice,
* Note: The format of the output is identical to the output of `openssl s_client -trace` or `openssl s_server -trace`. While it is produced by OpenSSL's`SSL_trace()` function, the format is
* undocumented, can change without notice,
* and should not be relied on.
* @since v12.2.0
*/
enableTrace(): void;
/**
* Returns the peer certificate as an `X509Certificate` object.
*
* If there is no peer certificate, or the socket has been destroyed,`undefined` will be returned.
* @since v15.9.0
*/
getPeerX509Certificate(): X509Certificate | undefined;
/**
* Returns the local certificate as an `X509Certificate` object.
*
* If there is no local certificate, or the socket has been destroyed,`undefined` will be returned.
* @since v15.9.0
*/
getX509Certificate(): X509Certificate | undefined;
/**
* Keying material is used for validations to prevent different kind of attacks in
* network protocols, for example in the specifications of IEEE 802.1X.
*
* Example
*
* ```js
* const keyingMaterial = tlsSocket.exportKeyingMaterial(
* 128,
* 'client finished');
*
*
* Example return value of keyingMaterial:
* <Buffer 76 26 af 99 c5 56 8e 42 09 91 ef 9f 93 cb ad 6c 7b 65 f8 53 f1 d8 d9
* 12 5a 33 b8 b5 25 df 7b 37 9f e0 e2 4f b8 67 83 a3 2f cd 5d 41 42 4c 91
* 74 ef 2c ... 78 more bytes>
*
* ```
*
* See the OpenSSL [`SSL_export_keying_material`](https://www.openssl.org/docs/man1.1.1/man3/SSL_export_keying_material.html) documentation for more
* information.
* @since v13.10.0, v12.17.0
* @param length number of bytes to retrieve from keying material
* @param label an application specific label, typically this will be a value from the
* [IANA Exporter Label Registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#exporter-labels).
* @param context optionally provide a context.
* @param label an application specific label, typically this will be a value from the [IANA Exporter Label
* Registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#exporter-labels).
* @param context Optionally provide a context.
* @return requested bytes of the keying material
*/
exportKeyingMaterial(length: number, label: string, context: Buffer): Buffer;
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "OCSPResponse", listener: (response: Buffer) => void): this;
addListener(event: "secureConnect", listener: () => void): this;
addListener(event: "session", listener: (session: Buffer) => void): this;
addListener(event: "keylog", listener: (line: Buffer) => void): this;
addListener(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
addListener(event: 'secureConnect', listener: () => void): this;
addListener(event: 'session', listener: (session: Buffer) => void): this;
addListener(event: 'keylog', listener: (line: Buffer) => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "OCSPResponse", response: Buffer): boolean;
emit(event: "secureConnect"): boolean;
emit(event: "session", session: Buffer): boolean;
emit(event: "keylog", line: Buffer): boolean;
emit(event: 'OCSPResponse', response: Buffer): boolean;
emit(event: 'secureConnect'): boolean;
emit(event: 'session', session: Buffer): boolean;
emit(event: 'keylog', line: Buffer): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "OCSPResponse", listener: (response: Buffer) => void): this;
on(event: "secureConnect", listener: () => void): this;
on(event: "session", listener: (session: Buffer) => void): this;
on(event: "keylog", listener: (line: Buffer) => void): this;
on(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
on(event: 'secureConnect', listener: () => void): this;
on(event: 'session', listener: (session: Buffer) => void): this;
on(event: 'keylog', listener: (line: Buffer) => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "OCSPResponse", listener: (response: Buffer) => void): this;
once(event: "secureConnect", listener: () => void): this;
once(event: "session", listener: (session: Buffer) => void): this;
once(event: "keylog", listener: (line: Buffer) => void): this;
once(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
once(event: 'secureConnect', listener: () => void): this;
once(event: 'session', listener: (session: Buffer) => void): this;
once(event: 'keylog', listener: (line: Buffer) => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "OCSPResponse", listener: (response: Buffer) => void): this;
prependListener(event: "secureConnect", listener: () => void): this;
prependListener(event: "session", listener: (session: Buffer) => void): this;
prependListener(event: "keylog", listener: (line: Buffer) => void): this;
prependListener(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
prependListener(event: 'secureConnect', listener: () => void): this;
prependListener(event: 'session', listener: (session: Buffer) => void): this;
prependListener(event: 'keylog', listener: (line: Buffer) => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "OCSPResponse", listener: (response: Buffer) => void): this;
prependOnceListener(event: "secureConnect", listener: () => void): this;
prependOnceListener(event: "session", listener: (session: Buffer) => void): this;
prependOnceListener(event: "keylog", listener: (line: Buffer) => void): this;
prependOnceListener(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
prependOnceListener(event: 'secureConnect', listener: () => void): this;
prependOnceListener(event: 'session', listener: (session: Buffer) => void): this;
prependOnceListener(event: 'keylog', listener: (line: Buffer) => void): this;
}
interface CommonConnectionOptions {
/**
* An optional TLS context object from tls.createSecureContext()
*/
secureContext?: SecureContext | undefined;
/**
* When enabled, TLS packet trace information is written to `stderr`. This can be
* used to debug TLS connection problems.
@ -377,7 +456,7 @@ declare module 'tls' {
* SecureContext.) If SNICallback wasn't provided the default callback
* with high-level API will be used (see below).
*/
SNICallback?: ((servername: string, cb: (err: Error | null, ctx: SecureContext) => void) => void) | undefined;
SNICallback?: ((servername: string, cb: (err: Error | null, ctx?: SecureContext) => void) => void) | undefined;
/**
* If true the server will reject any connection which is not
* authorized with the list of supplied CAs. This option only has an
@ -386,7 +465,6 @@ declare module 'tls' {
*/
rejectUnauthorized?: boolean | undefined;
}
interface TlsOptions extends SecureContextOptions, CommonConnectionOptions, net.ServerOpts {
/**
* Abort the connection if the SSL/TLS handshake does not finish in the
@ -405,7 +483,6 @@ declare module 'tls' {
* 48-bytes of cryptographically strong pseudo-random data.
*/
ticketKeys?: Buffer | undefined;
/**
*
* @param socket
@ -425,7 +502,6 @@ declare module 'tls' {
* requires explicitly specifying a cipher suite with the `ciphers` option.
* More information can be found in the RFC 4279.
*/
pskCallback?(socket: TLSSocket, identity: string): DataView | NodeJS.TypedArray | null;
/**
* hint to send to a client to help
@ -435,17 +511,15 @@ declare module 'tls' {
*/
pskIdentityHint?: string | undefined;
}
interface PSKCallbackNegotation {
psk: DataView | NodeJS.TypedArray;
identity: string;
}
interface ConnectionOptions extends SecureContextOptions, CommonConnectionOptions {
host?: string | undefined;
port?: number | undefined;
path?: string | undefined; // Creates unix socket connection to path. If this option is specified, `host` and `port` are ignored.
socket?: stream.Duplex | undefined; // Establish secure connection on a given socket rather than creating a new socket
socket?: net.Socket | undefined; // Establish secure connection on a given socket rather than creating a new socket
checkServerIdentity?: typeof checkServerIdentity | undefined;
servername?: string | undefined; // SNI TLS Extension
session?: Buffer | undefined;
@ -471,35 +545,50 @@ declare module 'tls' {
*/
pskCallback?(hint: string | null): PSKCallbackNegotation | null;
}
/**
* Accepts encrypted connections using TLS or SSL.
* @since v0.3.2
*/
class Server extends net.Server {
constructor(secureConnectionListener?: (socket: TLSSocket) => void);
constructor(options: TlsOptions, secureConnectionListener?: (socket: TLSSocket) => void);
/**
* The server.addContext() method adds a secure context that will be
* used if the client request's SNI name matches the supplied hostname
* (or wildcard).
* The `server.addContext()` method adds a secure context that will be used if
* the client request's SNI name matches the supplied `hostname` (or wildcard).
*
* When there are multiple matching contexts, the most recently added one is
* used.
* @since v0.5.3
* @param hostname A SNI host name or wildcard (e.g. `'*'`)
* @param context An object containing any of the possible properties from the {@link createSecureContext} `options` arguments (e.g. `key`, `cert`, `ca`, etc).
*/
addContext(hostName: string, credentials: SecureContextOptions): void;
addContext(hostname: string, context: SecureContextOptions): void;
/**
* Returns the session ticket keys.
*
* See `Session Resumption` for more information.
* @since v3.0.0
* @return A 48-byte buffer containing the session ticket keys.
*/
getTicketKeys(): Buffer;
/**
*
* The server.setSecureContext() method replaces the
* secure context of an existing server. Existing connections to the
* server are not interrupted.
* The `server.setSecureContext()` method replaces the secure context of an
* existing server. Existing connections to the server are not interrupted.
* @since v11.0.0
* @param options An object containing any of the possible properties from the {@link createSecureContext} `options` arguments (e.g. `key`, `cert`, `ca`, etc).
*/
setSecureContext(details: SecureContextOptions): void;
setSecureContext(options: SecureContextOptions): void;
/**
* The server.setSecureContext() method replaces the secure context of
* an existing server. Existing connections to the server are not
* interrupted.
* Sets the session ticket keys.
*
* Changes to the ticket keys are effective only for future server connections.
* Existing or currently pending server connections will use the previous keys.
*
* See `Session Resumption` for more information.
* @since v3.0.0
* @param keys A 48-byte buffer containing the session ticket keys.
*/
setTicketKeys(keys: Buffer): void;
/**
* events.EventEmitter
* 1. tlsClientError
@ -510,61 +599,56 @@ declare module 'tls' {
* 6. keylog
*/
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
addListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
addListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
addListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
addListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
addListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
addListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "tlsClientError", err: Error, tlsSocket: TLSSocket): boolean;
emit(event: "newSession", sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
emit(event: "OCSPRequest", certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
emit(event: "resumeSession", sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
emit(event: "secureConnection", tlsSocket: TLSSocket): boolean;
emit(event: "keylog", line: Buffer, tlsSocket: TLSSocket): boolean;
emit(event: 'tlsClientError', err: Error, tlsSocket: TLSSocket): boolean;
emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: () => void): boolean;
emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void): boolean;
emit(event: 'secureConnection', tlsSocket: TLSSocket): boolean;
emit(event: 'keylog', line: Buffer, tlsSocket: TLSSocket): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
on(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
on(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
on(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
on(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
on(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
on(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
on(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
on(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
once(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
once(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
once(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
once(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
once(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
once(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
once(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
once(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
prependListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
prependListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
prependListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
prependListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
prependListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
prependListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
prependOnceListener(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
prependOnceListener(event: "OCSPRequest", listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
prependOnceListener(event: "resumeSession", listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
prependOnceListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
}
/**
* @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
*/
interface SecurePair {
encrypted: TLSSocket;
cleartext: TLSSocket;
}
type SecureVersion = 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
interface SecureContextOptions {
/**
* Optionally override the trusted CA certificates. Default is to trust
@ -723,31 +807,183 @@ declare module 'tls' {
*/
sessionTimeout?: number | undefined;
}
interface SecureContext {
context: any;
}
/*
* Verifies the certificate `cert` is issued to host `host`.
* @host The hostname to verify the certificate against
* @cert PeerCertificate representing the peer's certificate
/**
* Verifies the certificate `cert` is issued to `hostname`.
*
* Returns Error object, populating it with the reason, host and cert on failure. On success, returns undefined.
* Returns [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) object, populating it with `reason`, `host`, and `cert` on
* failure. On success, returns [undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type).
*
* This function can be overwritten by providing alternative function as part of
* the `options.checkServerIdentity` option passed to `tls.connect()`. The
* overwriting function can call `tls.checkServerIdentity()` of course, to augment
* the checks done with additional verification.
*
* This function is only called if the certificate passed all other checks, such as
* being issued by trusted CA (`options.ca`).
* @since v0.8.4
* @param hostname The host name or IP address to verify the certificate against.
* @param cert A `certificate object` representing the peer's certificate.
*/
function checkServerIdentity(hostname: string, cert: PeerCertificate): Error | undefined;
/**
* Creates a new {@link Server}. The `secureConnectionListener`, if provided, is
* automatically set as a listener for the `'secureConnection'` event.
*
* The `ticketKeys` options is automatically shared between `cluster` module
* workers.
*
* The following illustrates a simple echo server:
*
* ```js
* const tls = require('tls');
* const fs = require('fs');
*
* const options = {
* key: fs.readFileSync('server-key.pem'),
* cert: fs.readFileSync('server-cert.pem'),
*
* // This is necessary only if using client certificate authentication.
* requestCert: true,
*
* // This is necessary only if the client uses a self-signed certificate.
* ca: [ fs.readFileSync('client-cert.pem') ]
* };
*
* const server = tls.createServer(options, (socket) => {
* console.log('server connected',
* socket.authorized ? 'authorized' : 'unauthorized');
* socket.write('welcome!\n');
* socket.setEncoding('utf8');
* socket.pipe(socket);
* });
* server.listen(8000, () => {
* console.log('server bound');
* });
* ```
*
* The server can be tested by connecting to it using the example client from {@link connect}.
* @since v0.3.2
*/
function checkServerIdentity(host: string, cert: PeerCertificate): Error | undefined;
function createServer(secureConnectionListener?: (socket: TLSSocket) => void): Server;
function createServer(options: TlsOptions, secureConnectionListener?: (socket: TLSSocket) => void): Server;
/**
* The `callback` function, if specified, will be added as a listener for the `'secureConnect'` event.
*
* `tls.connect()` returns a {@link TLSSocket} object.
*
* Unlike the `https` API, `tls.connect()` does not enable the
* SNI (Server Name Indication) extension by default, which may cause some
* servers to return an incorrect certificate or reject the connection
* altogether. To enable SNI, set the `servername` option in addition
* to `host`.
*
* The following illustrates a client for the echo server example from {@link createServer}:
*
* ```js
* // Assumes an echo server that is listening on port 8000.
* const tls = require('tls');
* const fs = require('fs');
*
* const options = {
* // Necessary only if the server requires client certificate authentication.
* key: fs.readFileSync('client-key.pem'),
* cert: fs.readFileSync('client-cert.pem'),
*
* // Necessary only if the server uses a self-signed certificate.
* ca: [ fs.readFileSync('server-cert.pem') ],
*
* // Necessary only if the server's cert isn't for "localhost".
* checkServerIdentity: () => { return null; },
* };
*
* const socket = tls.connect(8000, options, () => {
* console.log('client connected',
* socket.authorized ? 'authorized' : 'unauthorized');
* process.stdin.pipe(socket);
* process.stdin.resume();
* });
* socket.setEncoding('utf8');
* socket.on('data', (data) => {
* console.log(data);
* });
* socket.on('end', () => {
* console.log('server ends connection');
* });
* ```
* @since v0.11.3
*/
function connect(options: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
/**
* @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
* Creates a new secure pair object with two streams, one of which reads and writes
* the encrypted data and the other of which reads and writes the cleartext data.
* Generally, the encrypted stream is piped to/from an incoming encrypted data
* stream and the cleartext one is used as a replacement for the initial encrypted
* stream.
*
* `tls.createSecurePair()` returns a `tls.SecurePair` object with `cleartext` and`encrypted` stream properties.
*
* Using `cleartext` has the same API as {@link TLSSocket}.
*
* The `tls.createSecurePair()` method is now deprecated in favor of`tls.TLSSocket()`. For example, the code:
*
* ```js
* pair = tls.createSecurePair(// ... );
* pair.encrypted.pipe(socket);
* socket.pipe(pair.encrypted);
* ```
*
* can be replaced by:
*
* ```js
* secureSocket = tls.TLSSocket(socket, options);
* ```
*
* where `secureSocket` has the same API as `pair.cleartext`.
* @since v0.3.2
* @deprecated Since v0.11.3 - Use {@link TLSSocket} instead.
* @param context A secure context object as returned by `tls.createSecureContext()`
* @param isServer `true` to specify that this TLS connection should be opened as a server.
* @param requestCert `true` to specify whether a server should request a certificate from a connecting client. Only applies when `isServer` is `true`.
* @param rejectUnauthorized If not `false` a server automatically reject clients with invalid certificates. Only applies when `isServer` is `true`.
*/
function createSecurePair(context?: SecureContext, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
/**
* {@link createServer} sets the default value of the `honorCipherOrder` option
* to `true`, other APIs that create secure contexts leave it unset.
*
* {@link createServer} uses a 128 bit truncated SHA1 hash value generated
* from `process.argv` as the default value of the `sessionIdContext` option, other
* APIs that create secure contexts have no default value.
*
* The `tls.createSecureContext()` method creates a `SecureContext` object. It is
* usable as an argument to several `tls` APIs, such as {@link createServer} and `server.addContext()`, but has no public methods.
*
* A key is _required_ for ciphers that use certificates. Either `key` or`pfx` can be used to provide it.
*
* If the `ca` option is not given, then Node.js will default to using [Mozilla's publicly trusted list of
* CAs](https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt).
* @since v0.11.13
*/
function createSecurePair(credentials?: SecureContext, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
function createSecureContext(options?: SecureContextOptions): SecureContext;
/**
* Returns an array with the names of the supported TLS ciphers. The names are
* lower-case for historical reasons, but must be uppercased to be used in
* the `ciphers` option of {@link createSecureContext}.
*
* Cipher names that start with `'tls_'` are for TLSv1.3, all the others are for
* TLSv1.2 and below.
*
* ```js
* console.log(tls.getCiphers()); // ['aes128-gcm-sha256', 'aes128-sha', ...]
* ```
* @since v0.10.2
*/
function getCiphers(): string[];
/**
* The default curve name to use for ECDH key agreement in a tls server.
* The default value is 'auto'. See tls.createSecureContext() for further
@ -774,7 +1010,6 @@ declare module 'tls' {
* are provided, the lowest minimum is used.
*/
let DEFAULT_MIN_VERSION: SecureVersion;
/**
* An immutable array of strings representing the root certificates (in PEM
* format) used for verifying peer certificates. This is the default value

117
packages/node_modules/@node-red/editor-client/src/types/node/trace_events.d.ts vendored
View File

@ -1,6 +1,83 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `trace_events` module provides a mechanism to centralize tracing information
* generated by V8, Node.js core, and userspace code.
*
* Tracing can be enabled with the `--trace-event-categories` command-line flag
* or by using the `trace_events` module. The `--trace-event-categories` flag
* accepts a list of comma-separated category names.
*
* The available categories are:
*
* * `node`: An empty placeholder.
* * `node.async_hooks`: Enables capture of detailed `async_hooks` trace data.
* The `async_hooks` events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property.
* * `node.bootstrap`: Enables capture of Node.js bootstrap milestones.
* * `node.console`: Enables capture of `console.time()` and `console.count()`output.
* * `node.dns.native`: Enables capture of trace data for DNS queries.
* * `node.environment`: Enables capture of Node.js Environment milestones.
* * `node.fs.sync`: Enables capture of trace data for file system sync methods.
* * `node.perf`: Enables capture of `Performance API` measurements.
* * `node.perf.usertiming`: Enables capture of only Performance API User Timing
* measures and marks.
* * `node.perf.timerify`: Enables capture of only Performance API timerify
* measurements.
* * `node.promises.rejections`: Enables capture of trace data tracking the number
* of unhandled Promise rejections and handled-after-rejections.
* * `node.vm.script`: Enables capture of trace data for the `vm` module's`runInNewContext()`, `runInContext()`, and `runInThisContext()` methods.
* * `v8`: The `V8` events are GC, compiling, and execution related.
*
* By default the `node`, `node.async_hooks`, and `v8` categories are enabled.
*
* ```bash
* node --trace-event-categories v8,node,node.async_hooks server.js
* ```
*
* Prior versions of Node.js required the use of the `--trace-events-enabled`flag to enable trace events. This requirement has been removed. However, the`--trace-events-enabled` flag _may_ still be
* used and will enable the`node`, `node.async_hooks`, and `v8` trace event categories by default.
*
* ```bash
* node --trace-events-enabled
*
* # is equivalent to
*
* node --trace-event-categories v8,node,node.async_hooks
* ```
*
* Alternatively, trace events may be enabled using the `trace_events` module:
*
* ```js
* const trace_events = require('trace_events');
* const tracing = trace_events.createTracing({ categories: ['node.perf'] });
* tracing.enable(); // Enable trace event capture for the 'node.perf' category
*
* // do work
*
* tracing.disable(); // Disable trace event capture for the 'node.perf' category
* ```
*
* Running Node.js with tracing enabled will produce log files that can be opened
* in the [`chrome://tracing`](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool) tab of Chrome.
*
* The logging file is by default called `node_trace.${rotation}.log`, where`${rotation}` is an incrementing log-rotation id. The filepath pattern can
* be specified with `--trace-event-file-pattern` that accepts a template
* string that supports `${rotation}` and `${pid}`:
*
* ```bash
* node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js
* ```
*
* The tracing system uses the same time source
* as the one used by `process.hrtime()`.
* However the trace-event timestamps are expressed in microseconds,
* unlike `process.hrtime()` which returns nanoseconds.
*
* The features from this module are not available in `Worker` threads.
* @experimental
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/trace_events.js)
*/
declare module 'trace_events' {
/**
* The `Tracing` object is used to enable or disable tracing for sets of
@ -18,7 +95,6 @@ declare module 'trace_events' {
* `Tracing` object.
*/
readonly categories: string;
/**
* Disables this `Tracing` object.
*
@ -27,19 +103,16 @@ declare module 'trace_events' {
* will be disabled.
*/
disable(): void;
/**
* Enables this `Tracing` object for the set of categories covered by
* the `Tracing` object.
*/
enable(): void;
/**
* `true` only if the `Tracing` object has been enabled.
*/
readonly enabled: boolean;
}
interface CreateTracingOptions {
/**
* An array of trace category names. Values included in the array are
@ -48,17 +121,41 @@ declare module 'trace_events' {
*/
categories: string[];
}
/**
* Creates and returns a Tracing object for the given set of categories.
* Creates and returns a `Tracing` object for the given set of `categories`.
*
* ```js
* const trace_events = require('trace_events');
* const categories = ['node.perf', 'node.async_hooks'];
* const tracing = trace_events.createTracing({ categories });
* tracing.enable();
* // do stuff
* tracing.disable();
* ```
* @since v10.0.0
* @return .
*/
function createTracing(options: CreateTracingOptions): Tracing;
/**
* Returns a comma-separated list of all currently-enabled trace event
* categories. The current set of enabled trace event categories is
* determined by the union of all currently-enabled `Tracing` objects and
* any categories enabled using the `--trace-event-categories` flag.
* categories. The current set of enabled trace event categories is determined
* by the _union_ of all currently-enabled `Tracing` objects and any categories
* enabled using the `--trace-event-categories` flag.
*
* Given the file `test.js` below, the command`node --trace-event-categories node.perf test.js` will print`'node.async_hooks,node.perf'` to the console.
*
* ```js
* const trace_events = require('trace_events');
* const t1 = trace_events.createTracing({ categories: ['node.async_hooks'] });
* const t2 = trace_events.createTracing({ categories: ['node.perf'] });
* const t3 = trace_events.createTracing({ categories: ['v8'] });
*
* t1.enable();
* t2.enable();
*
* console.log(trace_events.getEnabledCategories());
* ```
* @since v10.0.0
*/
function getEnabledCategories(): string | undefined;
}

181
packages/node_modules/@node-red/editor-client/src/types/node/tty.d.ts vendored
View File

@ -1,14 +1,71 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `tty` module provides the `tty.ReadStream` and `tty.WriteStream` classes.
* In most cases, it will not be necessary or possible to use this module directly.
* However, it can be accessed using:
*
* ```js
* const tty = require('tty');
* ```
*
* When Node.js detects that it is being run with a text terminal ("TTY")
* attached, `process.stdin` will, by default, be initialized as an instance of`tty.ReadStream` and both `process.stdout` and `process.stderr` will, by
* default, be instances of `tty.WriteStream`. The preferred method of determining
* whether Node.js is being run within a TTY context is to check that the value of
* the `process.stdout.isTTY` property is `true`:
*
* ```console
* $ node -p -e "Boolean(process.stdout.isTTY)"
* true
* $ node -p -e "Boolean(process.stdout.isTTY)" | cat
* false
* ```
*
* In most cases, there should be little to no reason for an application to
* manually create instances of the `tty.ReadStream` and `tty.WriteStream`classes.
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/tty.js)
*/
declare module 'tty' {
import * as net from 'net';
import * as net from 'node:net';
/**
* The `tty.isatty()` method returns `true` if the given `fd` is associated with
* a TTY and `false` if it is not, including whenever `fd` is not a non-negative
* integer.
* @since v0.5.8
* @param fd A numeric file descriptor
*/
function isatty(fd: number): boolean;
/**
* Represents the readable side of a TTY. In normal circumstances `process.stdin` will be the only `tty.ReadStream` instance in a Node.js
* process and there should be no reason to create additional instances.
* @since v0.5.8
*/
class ReadStream extends net.Socket {
constructor(fd: number, options?: net.SocketConstructorOpts);
/**
* A `boolean` that is `true` if the TTY is currently configured to operate as a
* raw device. Defaults to `false`.
* @since v0.7.7
*/
isRaw: boolean;
/**
* Allows configuration of `tty.ReadStream` so that it operates as a raw device.
*
* When in raw mode, input is always available character-by-character, not
* including modifiers. Additionally, all special processing of characters by the
* terminal is disabled, including echoing input characters.Ctrl+C will no longer cause a `SIGINT` when in this mode.
* @since v0.7.7
* @param mode If `true`, configures the `tty.ReadStream` to operate as a raw device. If `false`, configures the `tty.ReadStream` to operate in its default mode. The `readStream.isRaw`
* property will be set to the resulting mode.
* @return The read stream instance.
*/
setRawMode(mode: boolean): this;
/**
* A `boolean` that is always `true` for `tty.ReadStream` instances.
* @since v0.5.8
*/
isTTY: boolean;
}
/**
@ -17,53 +74,131 @@ declare module 'tty' {
* 1 - to the right from cursor
*/
type Direction = -1 | 0 | 1;
/**
* Represents the writable side of a TTY. In normal circumstances,`process.stdout` and `process.stderr` will be the only`tty.WriteStream` instances created for a Node.js process and there
* should be no reason to create additional instances.
* @since v0.5.8
*/
class WriteStream extends net.Socket {
constructor(fd: number);
addListener(event: string, listener: (...args: any[]) => void): this;
addListener(event: "resize", listener: () => void): this;
addListener(event: 'resize', listener: () => void): this;
emit(event: string | symbol, ...args: any[]): boolean;
emit(event: "resize"): boolean;
emit(event: 'resize'): boolean;
on(event: string, listener: (...args: any[]) => void): this;
on(event: "resize", listener: () => void): this;
on(event: 'resize', listener: () => void): this;
once(event: string, listener: (...args: any[]) => void): this;
once(event: "resize", listener: () => void): this;
once(event: 'resize', listener: () => void): this;
prependListener(event: string, listener: (...args: any[]) => void): this;
prependListener(event: "resize", listener: () => void): this;
prependListener(event: 'resize', listener: () => void): this;
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
prependOnceListener(event: "resize", listener: () => void): this;
prependOnceListener(event: 'resize', listener: () => void): this;
/**
* Clears the current line of this WriteStream in a direction identified by `dir`.
* `writeStream.clearLine()` clears the current line of this `WriteStream` in a
* direction identified by `dir`.
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
clearLine(dir: Direction, callback?: () => void): boolean;
/**
* Clears this `WriteStream` from the current cursor down.
* `writeStream.clearScreenDown()` clears this `WriteStream` from the current
* cursor down.
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
clearScreenDown(callback?: () => void): boolean;
/**
* Moves this WriteStream's cursor to the specified position.
* `writeStream.cursorTo()` moves this `WriteStream`'s cursor to the specified
* position.
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
cursorTo(x: number, y?: number, callback?: () => void): boolean;
cursorTo(x: number, callback: () => void): boolean;
/**
* Moves this WriteStream's cursor relative to its current position.
* `writeStream.moveCursor()` moves this `WriteStream`'s cursor _relative_ to its
* current position.
* @since v0.7.7
* @param callback Invoked once the operation completes.
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
*/
moveCursor(dx: number, dy: number, callback?: () => void): boolean;
/**
* @default `process.env`
* Returns:
*
* * `1` for 2,
* * `4` for 16,
* * `8` for 256,
* * `24` for 16,777,216 colors supported.
*
* Use this to determine what colors the terminal supports. Due to the nature of
* colors in terminals it is possible to either have false positives or false
* negatives. It depends on process information and the environment variables that
* may lie about what terminal is used.
* It is possible to pass in an `env` object to simulate the usage of a specific
* terminal. This can be useful to check how specific environment settings behave.
*
* To enforce a specific color support, use one of the below environment settings.
*
* * 2 colors: `FORCE_COLOR = 0` (Disables colors)
* * 16 colors: `FORCE_COLOR = 1`
* * 256 colors: `FORCE_COLOR = 2`
* * 16,777,216 colors: `FORCE_COLOR = 3`
*
* Disabling color support is also possible by using the `NO_COLOR` and`NODE_DISABLE_COLORS` environment variables.
* @since v9.9.0
* @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
*/
getColorDepth(env?: object): number;
/**
* Returns `true` if the `writeStream` supports at least as many colors as provided
* in `count`. Minimum support is 2 (black and white).
*
* This has the same false positives and negatives as described in `writeStream.getColorDepth()`.
*
* ```js
* process.stdout.hasColors();
* // Returns true or false depending on if `stdout` supports at least 16 colors.
* process.stdout.hasColors(256);
* // Returns true or false depending on if `stdout` supports at least 256 colors.
* process.stdout.hasColors({ TMUX: '1' });
* // Returns true.
* process.stdout.hasColors(2 ** 24, { TMUX: '1' });
* // Returns false (the environment setting pretends to support 2 ** 8 colors).
* ```
* @since v11.13.0, v10.16.0
* @param [count=16] The number of colors that are requested (minimum 2).
* @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
*/
hasColors(count?: number): boolean;
hasColors(env?: object): boolean;
hasColors(count: number, env?: object): boolean;
/**
* `writeStream.getWindowSize()` returns the size of the TTY
* corresponding to this `WriteStream`. The array is of the type`[numColumns, numRows]` where `numColumns` and `numRows` represent the number
* of columns and rows in the corresponding TTY.
* @since v0.7.7
*/
getColorDepth(env?: {}): number;
hasColors(depth?: number): boolean;
hasColors(env?: {}): boolean;
hasColors(depth: number, env?: {}): boolean;
getWindowSize(): [number, number];
/**
* A `number` specifying the number of columns the TTY currently has. This property
* is updated whenever the `'resize'` event is emitted.
* @since v0.7.7
*/
columns: number;
/**
* A `number` specifying the number of rows the TTY currently has. This property
* is updated whenever the `'resize'` event is emitted.
* @since v0.7.7
*/
rows: number;
/**
* A `boolean` that is always `true`.
* @since v0.5.8
*/
isTTY: boolean;
}
}

762
packages/node_modules/@node-red/editor-client/src/types/node/url.d.ts vendored
View File

@ -1,9 +1,19 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `url` module provides utilities for URL resolution and parsing. It can be
* accessed using:
*
* ```js
* import url from 'url';
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/url.js)
*/
declare module 'url' {
import { ParsedUrlQuery, ParsedUrlQueryInput } from 'querystring';
import { Blob } from 'node:buffer';
import { ClientRequestArgs } from 'node:http';
import { ParsedUrlQuery, ParsedUrlQueryInput } from 'node:querystring';
// Input to `url.format`
interface UrlObject {
auth?: string | null | undefined;
@ -18,7 +28,6 @@ declare module 'url' {
port?: string | number | null | undefined;
query?: string | null | ParsedUrlQueryInput | undefined;
}
// Output of `url.parse`
interface Url {
auth: string | null;
@ -34,85 +43,782 @@ declare module 'url' {
port: string | null;
query: string | null | ParsedUrlQuery;
}
interface UrlWithParsedQuery extends Url {
query: ParsedUrlQuery;
}
interface UrlWithStringQuery extends Url {
query: string | null;
}
/** @deprecated since v11.0.0 - Use the WHATWG URL API. */
function parse(urlStr: string): UrlWithStringQuery;
/** @deprecated since v11.0.0 - Use the WHATWG URL API. */
function parse(urlStr: string, parseQueryString: false | undefined, slashesDenoteHost?: boolean): UrlWithStringQuery;
/** @deprecated since v11.0.0 - Use the WHATWG URL API. */
function parse(urlStr: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
/** @deprecated since v11.0.0 - Use the WHATWG URL API. */
function parse(urlStr: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;
function format(URL: URL, options?: URLFormatOptions): string;
/** @deprecated since v11.0.0 - Use the WHATWG URL API. */
/**
* The `url.parse()` method takes a URL string, parses it, and returns a URL
* object.
*
* A `TypeError` is thrown if `urlString` is not a string.
*
* A `URIError` is thrown if the `auth` property is present but cannot be decoded.
*
* Use of the legacy `url.parse()` method is discouraged. Users should
* use the WHATWG `URL` API. Because the `url.parse()` method uses a
* lenient, non-standard algorithm for parsing URL strings, security
* issues can be introduced. Specifically, issues with [host name spoofing](https://hackerone.com/reports/678487) and
* incorrect handling of usernames and passwords have been identified.
*
* Deprecation of this API has been shelved for now primarily due to the the
* inability of the [WHATWG API to parse relative URLs](https://github.com/nodejs/node/issues/12682#issuecomment-1154492373).
* [Discussions are ongoing](https://github.com/whatwg/url/issues/531) for the best way to resolve this.
*
* @since v0.1.25
* @param urlString The URL string to parse.
* @param [parseQueryString=false] If `true`, the `query` property will always be set to an object returned by the {@link querystring} module's `parse()` method. If `false`, the `query` property
* on the returned URL object will be an unparsed, undecoded string.
* @param [slashesDenoteHost=false] If `true`, the first token after the literal string `//` and preceding the next `/` will be interpreted as the `host`. For instance, given `//foo/bar`, the
* result would be `{host: 'foo', pathname: '/bar'}` rather than `{pathname: '//foo/bar'}`.
*/
function parse(urlString: string): UrlWithStringQuery;
function parse(urlString: string, parseQueryString: false | undefined, slashesDenoteHost?: boolean): UrlWithStringQuery;
function parse(urlString: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
function parse(urlString: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;
/**
* The URL object has both a `toString()` method and `href` property that return string serializations of the URL.
* These are not, however, customizable in any way. The `url.format(URL[, options])` method allows for basic
* customization of the output.
* Returns a customizable serialization of a URL `String` representation of a `WHATWG URL` object.
*
* ```js
* import url from 'url';
* const myURL = new URL('https://a:b@測試?abc#foo');
*
* console.log(myURL.href);
* // Prints https://a:b@xn--g6w251d/?abc#foo
*
* console.log(myURL.toString());
* // Prints https://a:b@xn--g6w251d/?abc#foo
*
* console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));
* // Prints 'https://測試/?abc'
* ```
* @since v7.6.0
* @param urlObject A `WHATWG URL` object
* @param options
*/
function format(urlObject: URL, options?: URLFormatOptions): string;
/**
* The `url.format()` method returns a formatted URL string derived from`urlObject`.
*
* ```js
* const url = require('url');
* url.format({
* protocol: 'https',
* hostname: 'example.com',
* pathname: '/some/path',
* query: {
* page: 1,
* format: 'json'
* }
* });
*
* // => 'https://example.com/some/path?page=1&#x26;format=json'
* ```
*
* If `urlObject` is not an object or a string, `url.format()` will throw a `TypeError`.
*
* The formatting process operates as follows:
*
* * A new empty string `result` is created.
* * If `urlObject.protocol` is a string, it is appended as-is to `result`.
* * Otherwise, if `urlObject.protocol` is not `undefined` and is not a string, an `Error` is thrown.
* * For all string values of `urlObject.protocol` that _do not end_ with an ASCII
* colon (`:`) character, the literal string `:` will be appended to `result`.
* * If either of the following conditions is true, then the literal string `//`will be appended to `result`:
* * `urlObject.slashes` property is true;
* * `urlObject.protocol` begins with `http`, `https`, `ftp`, `gopher`, or`file`;
* * If the value of the `urlObject.auth` property is truthy, and either`urlObject.host` or `urlObject.hostname` are not `undefined`, the value of`urlObject.auth` will be coerced into a string
* and appended to `result`followed by the literal string `@`.
* * If the `urlObject.host` property is `undefined` then:
* * If the `urlObject.hostname` is a string, it is appended to `result`.
* * Otherwise, if `urlObject.hostname` is not `undefined` and is not a string,
* an `Error` is thrown.
* * If the `urlObject.port` property value is truthy, and `urlObject.hostname`is not `undefined`:
* * The literal string `:` is appended to `result`, and
* * The value of `urlObject.port` is coerced to a string and appended to`result`.
* * Otherwise, if the `urlObject.host` property value is truthy, the value of`urlObject.host` is coerced to a string and appended to `result`.
* * If the `urlObject.pathname` property is a string that is not an empty string:
* * If the `urlObject.pathname`_does not start_ with an ASCII forward slash
* (`/`), then the literal string `'/'` is appended to `result`.
* * The value of `urlObject.pathname` is appended to `result`.
* * Otherwise, if `urlObject.pathname` is not `undefined` and is not a string, an `Error` is thrown.
* * If the `urlObject.search` property is `undefined` and if the `urlObject.query`property is an `Object`, the literal string `?` is appended to `result`followed by the output of calling the
* `querystring` module's `stringify()`method passing the value of `urlObject.query`.
* * Otherwise, if `urlObject.search` is a string:
* * If the value of `urlObject.search`_does not start_ with the ASCII question
* mark (`?`) character, the literal string `?` is appended to `result`.
* * The value of `urlObject.search` is appended to `result`.
* * Otherwise, if `urlObject.search` is not `undefined` and is not a string, an `Error` is thrown.
* * If the `urlObject.hash` property is a string:
* * If the value of `urlObject.hash`_does not start_ with the ASCII hash (`#`)
* character, the literal string `#` is appended to `result`.
* * The value of `urlObject.hash` is appended to `result`.
* * Otherwise, if the `urlObject.hash` property is not `undefined` and is not a
* string, an `Error` is thrown.
* * `result` is returned.
* @since v0.1.25
* @deprecated Legacy: Use the WHATWG URL API instead.
* @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise). If a string, it is converted to an object by passing it to `url.parse()`.
*/
function format(urlObject: UrlObject | string): string;
/** @deprecated since v11.0.0 - Use the WHATWG URL API. */
/**
* The `url.resolve()` method resolves a target URL relative to a base URL in a
* manner similar to that of a Web browser resolving an anchor tag HREF.
*
* ```js
* const url = require('url');
* url.resolve('/one/two/three', 'four'); // '/one/two/four'
* url.resolve('http://example.com/', '/one'); // 'http://example.com/one'
* url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'
* ```
*
* You can achieve the same result using the WHATWG URL API:
*
* ```js
* function resolve(from, to) {
* const resolvedUrl = new URL(to, new URL(from, 'resolve://'));
* if (resolvedUrl.protocol === 'resolve:') {
* // `from` is a relative URL.
* const { pathname, search, hash } = resolvedUrl;
* return pathname + search + hash;
* }
* return resolvedUrl.toString();
* }
*
* resolve('/one/two/three', 'four'); // '/one/two/four'
* resolve('http://example.com/', '/one'); // 'http://example.com/one'
* resolve('http://example.com/one', '/two'); // 'http://example.com/two'
* ```
* @since v0.1.25
* @deprecated Legacy: Use the WHATWG URL API instead.
* @param from The Base URL being resolved against.
* @param to The HREF URL being resolved.
*/
function resolve(from: string, to: string): string;
/**
* Returns the [Punycode](https://tools.ietf.org/html/rfc5891#section-4.4) ASCII serialization of the `domain`. If `domain` is an
* invalid domain, the empty string is returned.
*
* It performs the inverse operation to {@link domainToUnicode}.
*
* This feature is only available if the `node` executable was compiled with `ICU` enabled. If not, the domain names are passed through unchanged.
*
* ```js
* import url from 'url';
*
* console.log(url.domainToASCII('español.com'));
* // Prints xn--espaol-zwa.com
* console.log(url.domainToASCII('中文.com'));
* // Prints xn--fiq228c.com
* console.log(url.domainToASCII('xn--iñvalid.com'));
* // Prints an empty string
* ```
* @since v7.4.0, v6.13.0
*/
function domainToASCII(domain: string): string;
/**
* Returns the Unicode serialization of the `domain`. If `domain` is an invalid
* domain, the empty string is returned.
*
* It performs the inverse operation to {@link domainToASCII}.
*
* This feature is only available if the `node` executable was compiled with `ICU` enabled. If not, the domain names are passed through unchanged.
*
* ```js
* import url from 'url';
*
* console.log(url.domainToUnicode('xn--espaol-zwa.com'));
* // Prints español.com
* console.log(url.domainToUnicode('xn--fiq228c.com'));
* // Prints 中文.com
* console.log(url.domainToUnicode('xn--iñvalid.com'));
* // Prints an empty string
* ```
* @since v7.4.0, v6.13.0
*/
function domainToUnicode(domain: string): string;
/**
* This function ensures the correct decodings of percent-encoded characters as
* well as ensuring a cross-platform valid absolute path string.
*
* ```js
* import { fileURLToPath } from 'url';
*
* const __filename = fileURLToPath(import.meta.url);
*
* new URL('file:///C:/path/').pathname; // Incorrect: /C:/path/
* fileURLToPath('file:///C:/path/'); // Correct: C:\path\ (Windows)
*
* new URL('file://nas/foo.txt').pathname; // Incorrect: /foo.txt
* fileURLToPath('file://nas/foo.txt'); // Correct: \\nas\foo.txt (Windows)
*
* new URL('file:///你好.txt').pathname; // Incorrect: /%E4%BD%A0%E5%A5%BD.txt
* fileURLToPath('file:///你好.txt'); // Correct: /你好.txt (POSIX)
*
* new URL('file:///hello world').pathname; // Incorrect: /hello%20world
* fileURLToPath('file:///hello world'); // Correct: /hello world (POSIX)
* ```
* @since v10.12.0
* @param url The file URL string or URL object to convert to a path.
* @return The fully-resolved platform-specific Node.js file path.
*/
function fileURLToPath(url: string | URL): string;
/**
* This function ensures that path is resolved absolutely, and that the URL
* This function ensures that `path` is resolved absolutely, and that the URL
* control characters are correctly encoded when converting into a File URL.
* @param url The path to convert to a File URL.
*
* ```js
* import { pathToFileURL } from 'url';
*
* new URL('/foo#1', 'file:'); // Incorrect: file:///foo#1
* pathToFileURL('/foo#1'); // Correct: file:///foo%231 (POSIX)
*
* new URL('/some/path%.c', 'file:'); // Incorrect: file:///some/path%.c
* pathToFileURL('/some/path%.c'); // Correct: file:///some/path%25.c (POSIX)
* ```
* @since v10.12.0
* @param path The path to convert to a File URL.
* @return The file URL object.
*/
function pathToFileURL(url: string): URL;
function pathToFileURL(path: string): URL;
/**
* This utility function converts a URL object into an ordinary options object as
* expected by the `http.request()` and `https.request()` APIs.
*
* ```js
* import { urlToHttpOptions } from 'url';
* const myURL = new URL('https://a:b@測試?abc#foo');
*
* console.log(urlToHttpOptions(myURL));
*
* {
* protocol: 'https:',
* hostname: 'xn--g6w251d',
* hash: '#foo',
* search: '?abc',
* pathname: '/',
* path: '/?abc',
* href: 'https://a:b@xn--g6w251d/?abc#foo',
* auth: 'a:b'
* }
*
* ```
* @since v15.7.0
* @param url The `WHATWG URL` object to convert to an options object.
* @return Options object
*/
function urlToHttpOptions(url: URL): ClientRequestArgs;
interface URLFormatOptions {
auth?: boolean | undefined;
fragment?: boolean | undefined;
search?: boolean | undefined;
unicode?: boolean | undefined;
}
/**
* Browser-compatible `URL` class, implemented by following the WHATWG URL
* Standard. [Examples of parsed URLs](https://url.spec.whatwg.org/#example-url-parsing) may be found in the Standard itself.
* The `URL` class is also available on the global object.
*
* In accordance with browser conventions, all properties of `URL` objects
* are implemented as getters and setters on the class prototype, rather than as
* data properties on the object itself. Thus, unlike `legacy urlObject` s,
* using the `delete` keyword on any properties of `URL` objects (e.g. `delete myURL.protocol`, `delete myURL.pathname`, etc) has no effect but will still
* return `true`.
* @since v7.0.0, v6.13.0
*/
class URL {
/**
* Creates a `'blob:nodedata:...'` URL string that represents the given `Blob` object and can be used to retrieve the `Blob` later.
*
* ```js
* const {
* Blob,
* resolveObjectURL,
* } = require('buffer');
*
* const blob = new Blob(['hello']);
* const id = URL.createObjectURL(blob);
*
* // later...
*
* const otherBlob = resolveObjectURL(id);
* console.log(otherBlob.size);
* ```
*
* The data stored by the registered `Blob` will be retained in memory until`URL.revokeObjectURL()` is called to remove it.
*
* `Blob` objects are registered within the current thread. If using Worker
* Threads, `Blob` objects registered within one Worker will not be available
* to other workers or the main thread.
* @since v16.7.0
* @experimental
*/
static createObjectURL(blob: Blob): string;
/**
* Removes the stored `Blob` identified by the given ID.
* @since v16.7.0
* @experimental
* @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.
*/
static revokeObjectURL(objectUrl: string): void;
constructor(input: string, base?: string | URL);
/**
* Gets and sets the fragment portion of the URL.
*
* ```js
* const myURL = new URL('https://example.org/foo#bar');
* console.log(myURL.hash);
* // Prints #bar
*
* myURL.hash = 'baz';
* console.log(myURL.href);
* // Prints https://example.org/foo#baz
* ```
*
* Invalid URL characters included in the value assigned to the `hash` property
* are `percent-encoded`. The selection of which characters to
* percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.
*/
hash: string;
/**
* Gets and sets the host portion of the URL.
*
* ```js
* const myURL = new URL('https://example.org:81/foo');
* console.log(myURL.host);
* // Prints example.org:81
*
* myURL.host = 'example.com:82';
* console.log(myURL.href);
* // Prints https://example.com:82/foo
* ```
*
* Invalid host values assigned to the `host` property are ignored.
*/
host: string;
/**
* Gets and sets the host name portion of the URL. The key difference between`url.host` and `url.hostname` is that `url.hostname` does _not_ include the
* port.
*
* ```js
* const myURL = new URL('https://example.org:81/foo');
* console.log(myURL.hostname);
* // Prints example.org
*
* // Setting the hostname does not change the port
* myURL.hostname = 'example.com:82';
* console.log(myURL.href);
* // Prints https://example.com:81/foo
*
* // Use myURL.host to change the hostname and port
* myURL.host = 'example.org:82';
* console.log(myURL.href);
* // Prints https://example.org:82/foo
* ```
*
* Invalid host name values assigned to the `hostname` property are ignored.
*/
hostname: string;
/**
* Gets and sets the serialized URL.
*
* ```js
* const myURL = new URL('https://example.org/foo');
* console.log(myURL.href);
* // Prints https://example.org/foo
*
* myURL.href = 'https://example.com/bar';
* console.log(myURL.href);
* // Prints https://example.com/bar
* ```
*
* Getting the value of the `href` property is equivalent to calling {@link toString}.
*
* Setting the value of this property to a new value is equivalent to creating a
* new `URL` object using `new URL(value)`. Each of the `URL`object's properties will be modified.
*
* If the value assigned to the `href` property is not a valid URL, a `TypeError`will be thrown.
*/
href: string;
/**
* Gets the read-only serialization of the URL's origin.
*
* ```js
* const myURL = new URL('https://example.org/foo/bar?baz');
* console.log(myURL.origin);
* // Prints https://example.org
* ```
*
* ```js
* const idnURL = new URL('https://測試');
* console.log(idnURL.origin);
* // Prints https://xn--g6w251d
*
* console.log(idnURL.hostname);
* // Prints xn--g6w251d
* ```
*/
readonly origin: string;
/**
* Gets and sets the password portion of the URL.
*
* ```js
* const myURL = new URL('https://abc:xyz@example.com');
* console.log(myURL.password);
* // Prints xyz
*
* myURL.password = '123';
* console.log(myURL.href);
* // Prints https://abc:123@example.com
* ```
*
* Invalid URL characters included in the value assigned to the `password` property
* are `percent-encoded`. The selection of which characters to
* percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.
*/
password: string;
/**
* Gets and sets the path portion of the URL.
*
* ```js
* const myURL = new URL('https://example.org/abc/xyz?123');
* console.log(myURL.pathname);
* // Prints /abc/xyz
*
* myURL.pathname = '/abcdef';
* console.log(myURL.href);
* // Prints https://example.org/abcdef?123
* ```
*
* Invalid URL characters included in the value assigned to the `pathname`property are `percent-encoded`. The selection of which characters
* to percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.
*/
pathname: string;
/**
* Gets and sets the port portion of the URL.
*
* The port value may be a number or a string containing a number in the range`0` to `65535` (inclusive). Setting the value to the default port of the`URL` objects given `protocol` will
* result in the `port` value becoming
* the empty string (`''`).
*
* The port value can be an empty string in which case the port depends on
* the protocol/scheme:
*
* <omitted>
*
* Upon assigning a value to the port, the value will first be converted to a
* string using `.toString()`.
*
* If that string is invalid but it begins with a number, the leading number is
* assigned to `port`.
* If the number lies outside the range denoted above, it is ignored.
*
* ```js
* const myURL = new URL('https://example.org:8888');
* console.log(myURL.port);
* // Prints 8888
*
* // Default ports are automatically transformed to the empty string
* // (HTTPS protocol's default port is 443)
* myURL.port = '443';
* console.log(myURL.port);
* // Prints the empty string
* console.log(myURL.href);
* // Prints https://example.org/
*
* myURL.port = 1234;
* console.log(myURL.port);
* // Prints 1234
* console.log(myURL.href);
* // Prints https://example.org:1234/
*
* // Completely invalid port strings are ignored
* myURL.port = 'abcd';
* console.log(myURL.port);
* // Prints 1234
*
* // Leading numbers are treated as a port number
* myURL.port = '5678abcd';
* console.log(myURL.port);
* // Prints 5678
*
* // Non-integers are truncated
* myURL.port = 1234.5678;
* console.log(myURL.port);
* // Prints 1234
*
* // Out-of-range numbers which are not represented in scientific notation
* // will be ignored.
* myURL.port = 1e10; // 10000000000, will be range-checked as described below
* console.log(myURL.port);
* // Prints 1234
* ```
*
* Numbers which contain a decimal point,
* such as floating-point numbers or numbers in scientific notation,
* are not an exception to this rule.
* Leading numbers up to the decimal point will be set as the URL's port,
* assuming they are valid:
*
* ```js
* myURL.port = 4.567e21;
* console.log(myURL.port);
* // Prints 4 (because it is the leading number in the string '4.567e21')
* ```
*/
port: string;
/**
* Gets and sets the protocol portion of the URL.
*
* ```js
* const myURL = new URL('https://example.org');
* console.log(myURL.protocol);
* // Prints https:
*
* myURL.protocol = 'ftp';
* console.log(myURL.href);
* // Prints ftp://example.org/
* ```
*
* Invalid URL protocol values assigned to the `protocol` property are ignored.
*/
protocol: string;
/**
* Gets and sets the serialized query portion of the URL.
*
* ```js
* const myURL = new URL('https://example.org/abc?123');
* console.log(myURL.search);
* // Prints ?123
*
* myURL.search = 'abc=xyz';
* console.log(myURL.href);
* // Prints https://example.org/abc?abc=xyz
* ```
*
* Any invalid URL characters appearing in the value assigned the `search`property will be `percent-encoded`. The selection of which
* characters to percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.
*/
search: string;
/**
* Gets the `URLSearchParams` object representing the query parameters of the
* URL. This property is read-only but the `URLSearchParams` object it provides
* can be used to mutate the URL instance; to replace the entirety of query
* parameters of the URL, use the {@link search} setter. See `URLSearchParams` documentation for details.
*
* Use care when using `.searchParams` to modify the `URL` because,
* per the WHATWG specification, the `URLSearchParams` object uses
* different rules to determine which characters to percent-encode. For
* instance, the `URL` object will not percent encode the ASCII tilde (`~`)
* character, while `URLSearchParams` will always encode it:
*
* ```js
* const myUrl = new URL('https://example.org/abc?foo=~bar');
*
* console.log(myUrl.search); // prints ?foo=~bar
*
* // Modify the URL via searchParams...
* myUrl.searchParams.sort();
*
* console.log(myUrl.search); // prints ?foo=%7Ebar
* ```
*/
readonly searchParams: URLSearchParams;
/**
* Gets and sets the username portion of the URL.
*
* ```js
* const myURL = new URL('https://abc:xyz@example.com');
* console.log(myURL.username);
* // Prints abc
*
* myURL.username = '123';
* console.log(myURL.href);
* // Prints https://123:xyz@example.com/
* ```
*
* Any invalid URL characters appearing in the value assigned the `username`property will be `percent-encoded`. The selection of which
* characters to percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.
*/
username: string;
/**
* The `toString()` method on the `URL` object returns the serialized URL. The
* value returned is equivalent to that of {@link href} and {@link toJSON}.
*/
toString(): string;
/**
* The `toJSON()` method on the `URL` object returns the serialized URL. The
* value returned is equivalent to that of {@link href} and {@link toString}.
*
* This method is automatically called when an `URL` object is serialized
* with [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify).
*
* ```js
* const myURLs = [
* new URL('https://www.example.com'),
* new URL('https://test.example.org'),
* ];
* console.log(JSON.stringify(myURLs));
* // Prints ["https://www.example.com/","https://test.example.org/"]
* ```
*/
toJSON(): string;
}
/**
* The `URLSearchParams` API provides read and write access to the query of a`URL`. The `URLSearchParams` class can also be used standalone with one of the
* four following constructors.
* The `URLSearchParams` class is also available on the global object.
*
* The WHATWG `URLSearchParams` interface and the `querystring` module have
* similar purpose, but the purpose of the `querystring` module is more
* general, as it allows the customization of delimiter characters (`&#x26;` and `=`).
* On the other hand, this API is designed purely for URL query strings.
*
* ```js
* const myURL = new URL('https://example.org/?abc=123');
* console.log(myURL.searchParams.get('abc'));
* // Prints 123
*
* myURL.searchParams.append('abc', 'xyz');
* console.log(myURL.href);
* // Prints https://example.org/?abc=123&#x26;abc=xyz
*
* myURL.searchParams.delete('abc');
* myURL.searchParams.set('a', 'b');
* console.log(myURL.href);
* // Prints https://example.org/?a=b
*
* const newSearchParams = new URLSearchParams(myURL.searchParams);
* // The above is equivalent to
* // const newSearchParams = new URLSearchParams(myURL.search);
*
* newSearchParams.append('a', 'c');
* console.log(myURL.href);
* // Prints https://example.org/?a=b
* console.log(newSearchParams.toString());
* // Prints a=b&#x26;a=c
*
* // newSearchParams.toString() is implicitly called
* myURL.search = newSearchParams;
* console.log(myURL.href);
* // Prints https://example.org/?a=b&#x26;a=c
* newSearchParams.delete('a');
* console.log(myURL.href);
* // Prints https://example.org/?a=b&#x26;a=c
* ```
* @since v7.5.0, v6.13.0
*/
class URLSearchParams implements Iterable<[string, string]> {
constructor(init?: URLSearchParams | string | Record<string, string | ReadonlyArray<string>> | Iterable<[string, string]> | ReadonlyArray<[string, string]>);
/**
* Append a new name-value pair to the query string.
*/
append(name: string, value: string): void;
/**
* Remove all name-value pairs whose name is `name`.
*/
delete(name: string): void;
/**
* Returns an ES6 `Iterator` over each of the name-value pairs in the query.
* Each item of the iterator is a JavaScript `Array`. The first item of the `Array`is the `name`, the second item of the `Array` is the `value`.
*
* Alias for `urlSearchParams[@@iterator]()`.
*/
entries(): IterableIterator<[string, string]>;
forEach(callback: (value: string, name: string, searchParams: URLSearchParams) => void, thisArg?: any): void;
/**
* Iterates over each name-value pair in the query and invokes the given function.
*
* ```js
* const myURL = new URL('https://example.org/?a=b&#x26;c=d');
* myURL.searchParams.forEach((value, name, searchParams) => {
* console.log(name, value, myURL.searchParams === searchParams);
* });
* // Prints:
* // a b true
* // c d true
* ```
* @param fn Invoked for each name-value pair in the query
* @param thisArg To be used as `this` value for when `fn` is called
*/
forEach<TThis = this>(callback: (this: TThis, value: string, name: string, searchParams: URLSearchParams) => void, thisArg?: TThis): void;
/**
* Returns the value of the first name-value pair whose name is `name`. If there
* are no such pairs, `null` is returned.
* @return or `null` if there is no name-value pair with the given `name`.
*/
get(name: string): string | null;
/**
* Returns the values of all name-value pairs whose name is `name`. If there are
* no such pairs, an empty array is returned.
*/
getAll(name: string): string[];
/**
* Returns `true` if there is at least one name-value pair whose name is `name`.
*/
has(name: string): boolean;
/**
* Returns an ES6 `Iterator` over the names of each name-value pair.
*
* ```js
* const params = new URLSearchParams('foo=bar&#x26;foo=baz');
* for (const name of params.keys()) {
* console.log(name);
* }
* // Prints:
* // foo
* // foo
* ```
*/
keys(): IterableIterator<string>;
/**
* Sets the value in the `URLSearchParams` object associated with `name` to`value`. If there are any pre-existing name-value pairs whose names are `name`,
* set the first such pair's value to `value` and remove all others. If not,
* append the name-value pair to the query string.
*
* ```js
* const params = new URLSearchParams();
* params.append('foo', 'bar');
* params.append('foo', 'baz');
* params.append('abc', 'def');
* console.log(params.toString());
* // Prints foo=bar&#x26;foo=baz&#x26;abc=def
*
* params.set('foo', 'def');
* params.set('xyz', 'opq');
* console.log(params.toString());
* // Prints foo=def&#x26;abc=def&#x26;xyz=opq
* ```
*/
set(name: string, value: string): void;
/**
* Sort all existing name-value pairs in-place by their names. Sorting is done
* with a [stable sorting algorithm](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability), so relative order between name-value pairs
* with the same name is preserved.
*
* This method can be used, in particular, to increase cache hits.
*
* ```js
* const params = new URLSearchParams('query[]=abc&#x26;type=search&#x26;query[]=123');
* params.sort();
* console.log(params.toString());
* // Prints query%5B%5D=abc&#x26;query%5B%5D=123&#x26;type=search
* ```
* @since v7.7.0, v6.13.0
*/
sort(): void;
/**
* Returns the search parameters serialized as a string, with characters
* percent-encoded where necessary.
*/
toString(): string;
/**
* Returns an ES6 `Iterator` over the values of each name-value pair.
*/
values(): IterableIterator<string>;
[Symbol.iterator](): IterableIterator<[string, string]>;
}

1706
packages/node_modules/@node-red/editor-client/src/types/node/util.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

334
packages/node_modules/@node-red/editor-client/src/types/node/v8.d.ts vendored
View File

@ -1,9 +1,16 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
*
* ```js
* const v8 = require('v8');
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/v8.js)
*/
declare module 'v8' {
import { Readable } from 'stream';
import { Readable } from 'node:stream';
interface HeapSpaceInfo {
space_name: string;
space_size: number;
@ -11,10 +18,8 @@ declare module 'v8' {
space_available_size: number;
physical_space_size: number;
}
// ** Signifies if the --zap_code_space option is enabled or not. 1 == enabled, 0 == disabled. */
type DoesZapCodeSpaceFlag = 0 | 1;
interface HeapInfo {
total_heap_size: number;
total_heap_size_executable: number;
@ -28,165 +33,348 @@ declare module 'v8' {
number_of_native_contexts: number;
number_of_detached_contexts: number;
}
interface HeapCodeStatistics {
code_and_metadata_size: number;
bytecode_and_metadata_size: number;
external_script_source_size: number;
}
/**
* Returns an integer representing a "version tag" derived from the V8 version, command line flags and detected CPU features.
* This is useful for determining whether a vm.Script cachedData buffer is compatible with this instance of V8.
* Returns an integer representing a version tag derived from the V8 version,
* command-line flags, and detected CPU features. This is useful for determining
* whether a `vm.Script` `cachedData` buffer is compatible with this instance
* of V8.
*
* ```js
* console.log(v8.cachedDataVersionTag()); // 3947234607
* // The value returned by v8.cachedDataVersionTag() is derived from the V8
* // version, command-line flags, and detected CPU features. Test that the value
* // does indeed update when flags are toggled.
* v8.setFlagsFromString('--allow_natives_syntax');
* console.log(v8.cachedDataVersionTag()); // 183726201
* ```
* @since v8.0.0
*/
function cachedDataVersionTag(): number;
/**
* Returns an object with the following properties:
*
* `does_zap_garbage` is a 0/1 boolean, which signifies whether the`--zap_code_space` option is enabled or not. This makes V8 overwrite heap
* garbage with a bit pattern. The RSS footprint (resident set size) gets bigger
* because it continuously touches all heap pages and that makes them less likely
* to get swapped out by the operating system.
*
* `number_of_native_contexts` The value of native\_context is the number of the
* top-level contexts currently active. Increase of this number over time indicates
* a memory leak.
*
* `number_of_detached_contexts` The value of detached\_context is the number
* of contexts that were detached and not yet garbage collected. This number
* being non-zero indicates a potential memory leak.
*
* ```js
* {
* total_heap_size: 7326976,
* total_heap_size_executable: 4194304,
* total_physical_size: 7326976,
* total_available_size: 1152656,
* used_heap_size: 3476208,
* heap_size_limit: 1535115264,
* malloced_memory: 16384,
* peak_malloced_memory: 1127496,
* does_zap_garbage: 0,
* number_of_native_contexts: 1,
* number_of_detached_contexts: 0
* }
* ```
* @since v1.0.0
*/
function getHeapStatistics(): HeapInfo;
/**
* Returns statistics about the V8 heap spaces, i.e. the segments which make up
* the V8 heap. Neither the ordering of heap spaces, nor the availability of a
* heap space can be guaranteed as the statistics are provided via the
* V8[`GetHeapSpaceStatistics`](https://v8docs.nodesource.com/node-13.2/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4) function and may change from one V8 version to the
* next.
*
* The value returned is an array of objects containing the following properties:
*
* ```json
* [
* {
* "space_name": "new_space",
* "space_size": 2063872,
* "space_used_size": 951112,
* "space_available_size": 80824,
* "physical_space_size": 2063872
* },
* {
* "space_name": "old_space",
* "space_size": 3090560,
* "space_used_size": 2493792,
* "space_available_size": 0,
* "physical_space_size": 3090560
* },
* {
* "space_name": "code_space",
* "space_size": 1260160,
* "space_used_size": 644256,
* "space_available_size": 960,
* "physical_space_size": 1260160
* },
* {
* "space_name": "map_space",
* "space_size": 1094160,
* "space_used_size": 201608,
* "space_available_size": 0,
* "physical_space_size": 1094160
* },
* {
* "space_name": "large_object_space",
* "space_size": 0,
* "space_used_size": 0,
* "space_available_size": 1490980608,
* "physical_space_size": 0
* }
* ]
* ```
* @since v6.0.0
*/
function getHeapSpaceStatistics(): HeapSpaceInfo[];
/**
* The `v8.setFlagsFromString()` method can be used to programmatically set
* V8 command-line flags. This method should be used with care. Changing settings
* after the VM has started may result in unpredictable behavior, including
* crashes and data loss; or it may simply do nothing.
*
* The V8 options available for a version of Node.js may be determined by running`node --v8-options`.
*
* Usage:
*
* ```js
* // Print GC events to stdout for one minute.
* const v8 = require('v8');
* v8.setFlagsFromString('--trace_gc');
* setTimeout(() => { v8.setFlagsFromString('--notrace_gc'); }, 60e3);
* ```
* @since v1.0.0
*/
function setFlagsFromString(flags: string): void;
/**
* Generates a snapshot of the current V8 heap and returns a Readable
* Stream that may be used to read the JSON serialized representation.
* This conversation was marked as resolved by joyeecheung
* This JSON stream format is intended to be used with tools such as
* Chrome DevTools. The JSON schema is undocumented and specific to the
* V8 engine, and may change from one version of V8 to the next.
* V8 engine. Therefore, the schema may change from one version of V8 to the next.
*
* ```js
* // Print heap snapshot to the console
* const v8 = require('v8');
* const stream = v8.getHeapSnapshot();
* stream.pipe(process.stdout);
* ```
* @since v11.13.0
* @return A Readable Stream containing the V8 heap snapshot
*/
function getHeapSnapshot(): Readable;
/**
* Generates a snapshot of the current V8 heap and writes it to a JSON
* file. This file is intended to be used with tools such as Chrome
* DevTools. The JSON schema is undocumented and specific to the V8
* engine, and may change from one version of V8 to the next.
*
* @param fileName The file path where the V8 heap snapshot is to be
* saved. If not specified, a file name with the pattern
* `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
* generated, where `{pid}` will be the PID of the Node.js process,
* `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from
* the main Node.js thread or the id of a worker thread.
* A heap snapshot is specific to a single V8 isolate. When using `worker threads`, a heap snapshot generated from the main thread will
* not contain any information about the workers, and vice versa.
*
* ```js
* const { writeHeapSnapshot } = require('v8');
* const {
* Worker,
* isMainThread,
* parentPort
* } = require('worker_threads');
*
* if (isMainThread) {
* const worker = new Worker(__filename);
*
* worker.once('message', (filename) => {
* console.log(`worker heapdump: ${filename}`);
* // Now get a heapdump for the main thread.
* console.log(`main thread heapdump: ${writeHeapSnapshot()}`);
* });
*
* // Tell the worker to create a heapdump.
* worker.postMessage('heapdump');
* } else {
* parentPort.once('message', (message) => {
* if (message === 'heapdump') {
* // Generate a heapdump for the worker
* // and return the filename to the parent.
* parentPort.postMessage(writeHeapSnapshot());
* }
* });
* }
* ```
* @since v11.13.0
* @param filename The file path where the V8 heap snapshot is to be saved. If not specified, a file name with the pattern `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
* generated, where `{pid}` will be the PID of the Node.js process, `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from the main Node.js thread or the id of a
* worker thread.
* @return The filename where the snapshot was saved.
*/
function writeHeapSnapshot(filename?: string): string;
/**
* Returns an object with the following properties:
*
* ```js
* {
* code_and_metadata_size: 212208,
* bytecode_and_metadata_size: 161368,
* external_script_source_size: 1410794
* }
* ```
* @since v12.8.0
*/
function writeHeapSnapshot(fileName?: string): string;
function getHeapCodeStatistics(): HeapCodeStatistics;
/**
* @since v8.0.0
*/
class Serializer {
/**
* Writes out a header, which includes the serialization format version.
*/
writeHeader(): void;
/**
* Serializes a JavaScript value and adds the serialized representation to the internal buffer.
* This throws an error if value cannot be serialized.
* Serializes a JavaScript value and adds the serialized representation to the
* internal buffer.
*
* This throws an error if `value` cannot be serialized.
*/
writeValue(val: any): boolean;
/**
* Returns the stored internal buffer.
* This serializer should not be used once the buffer is released.
* Calling this method results in undefined behavior if a previous write has failed.
* Returns the stored internal buffer. This serializer should not be used once
* the buffer is released. Calling this method results in undefined behavior
* if a previous write has failed.
*/
releaseBuffer(): Buffer;
/**
* Marks an ArrayBuffer as having its contents transferred out of band.\
* Pass the corresponding ArrayBuffer in the deserializing context to deserializer.transferArrayBuffer().
* Marks an `ArrayBuffer` as having its contents transferred out of band.
* Pass the corresponding `ArrayBuffer` in the deserializing context to `deserializer.transferArrayBuffer()`.
* @param id A 32-bit unsigned integer.
* @param arrayBuffer An `ArrayBuffer` instance.
*/
transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
/**
* Write a raw 32-bit unsigned integer.
* For use inside of a custom `serializer._writeHostObject()`.
*/
writeUint32(value: number): void;
/**
* Write a raw 64-bit unsigned integer, split into high and low 32-bit parts.
* For use inside of a custom `serializer._writeHostObject()`.
*/
writeUint64(hi: number, lo: number): void;
/**
* Write a JS number value.
* Write a JS `number` value.
* For use inside of a custom `serializer._writeHostObject()`.
*/
writeDouble(value: number): void;
/**
* Write raw bytes into the serializer’s internal buffer.
* The deserializer will require a way to compute the length of the buffer.
* Write raw bytes into the serializer’s internal buffer. The deserializer
* will require a way to compute the length of the buffer.
* For use inside of a custom `serializer._writeHostObject()`.
*/
writeRawBytes(buffer: NodeJS.TypedArray): void;
}
/**
* A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
* and only stores the part of their underlying `ArrayBuffers` that they are referring to.
* A subclass of `Serializer` that serializes `TypedArray`(in particular `Buffer`) and `DataView` objects as host objects, and only
* stores the part of their underlying `ArrayBuffer`s that they are referring to.
* @since v8.0.0
*/
class DefaultSerializer extends Serializer {}
/**
* @since v8.0.0
*/
class DefaultSerializer extends Serializer {
}
class Deserializer {
constructor(data: NodeJS.TypedArray);
/**
* Reads and validates a header (including the format version).
* May, for example, reject an invalid or unsupported wire format.
* In that case, an Error is thrown.
* May, for example, reject an invalid or unsupported wire format. In that case,
* an `Error` is thrown.
*/
readHeader(): boolean;
/**
* Deserializes a JavaScript value from the buffer and returns it.
*/
readValue(): any;
/**
* Marks an ArrayBuffer as having its contents transferred out of band.
* Pass the corresponding `ArrayBuffer` in the serializing context to serializer.transferArrayBuffer()
* (or return the id from serializer._getSharedArrayBufferId() in the case of SharedArrayBuffers).
* Marks an `ArrayBuffer` as having its contents transferred out of band.
* Pass the corresponding `ArrayBuffer` in the serializing context to `serializer.transferArrayBuffer()` (or return the `id` from `serializer._getSharedArrayBufferId()` in the case of
* `SharedArrayBuffer`s).
* @param id A 32-bit unsigned integer.
* @param arrayBuffer An `ArrayBuffer` instance.
*/
transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer): void;
/**
* Reads the underlying wire format version.
* Likely mostly to be useful to legacy code reading old wire format versions.
* May not be called before .readHeader().
* Reads the underlying wire format version. Likely mostly to be useful to
* legacy code reading old wire format versions. May not be called before`.readHeader()`.
*/
getWireFormatVersion(): number;
/**
* Read a raw 32-bit unsigned integer and return it.
* For use inside of a custom `deserializer._readHostObject()`.
*/
readUint32(): number;
/**
* Read a raw 64-bit unsigned integer and return it as an array [hi, lo] with two 32-bit unsigned integer entries.
* Read a raw 64-bit unsigned integer and return it as an array `[hi, lo]`with two 32-bit unsigned integer entries.
* For use inside of a custom `deserializer._readHostObject()`.
*/
readUint64(): [number, number];
/**
* Read a JS number value.
* Read a JS `number` value.
* For use inside of a custom `deserializer._readHostObject()`.
*/
readDouble(): number;
/**
* Read raw bytes from the deserializer’s internal buffer.
* The length parameter must correspond to the length of the buffer that was passed to serializer.writeRawBytes().
* Read raw bytes from the deserializer’s internal buffer. The `length` parameter
* must correspond to the length of the buffer that was passed to `serializer.writeRawBytes()`.
* For use inside of a custom `deserializer._readHostObject()`.
*/
readRawBytes(length: number): Buffer;
}
/**
* A subclass of `Serializer` that serializes `TypedArray` (in particular `Buffer`) and `DataView` objects as host objects,
* and only stores the part of their underlying `ArrayBuffers` that they are referring to.
* A subclass of `Deserializer` corresponding to the format written by `DefaultSerializer`.
* @since v8.0.0
*/
class DefaultDeserializer extends Deserializer {
}
class DefaultDeserializer extends Deserializer {}
/**
* Uses a `DefaultSerializer` to serialize value into a buffer.
* Uses a `DefaultSerializer` to serialize `value` into a buffer.
* @since v8.0.0
*/
function serialize(value: any): Buffer;
/**
* Uses a `DefaultDeserializer` with default options to read a JS value from a buffer.
* Uses a `DefaultDeserializer` with default options to read a JS value
* from a buffer.
* @since v8.0.0
* @param buffer A buffer returned by {@link serialize}.
*/
function deserialize(data: NodeJS.TypedArray): any;
function deserialize(buffer: NodeJS.TypedArray): any;
/**
* The `v8.takeCoverage()` method allows the user to write the coverage started by `NODE_V8_COVERAGE` to disk on demand. This method can be invoked multiple
* times during the lifetime of the process. Each time the execution counter will
* be reset and a new coverage report will be written to the directory specified
* by `NODE_V8_COVERAGE`.
*
* When the process is about to exit, one last coverage will still be written to
* disk unless {@link stopCoverage} is invoked before the process exits.
* @since v15.1.0, v12.22.0
*/
function takeCoverage(): void;
/**
* The `v8.stopCoverage()` method allows the user to stop the coverage collection
* started by `NODE_V8_COVERAGE`, so that V8 can release the execution count
* records and optimize code. This can be used in conjunction with {@link takeCoverage} if the user wants to collect the coverage on demand.
* @since v15.1.0, v12.22.0
*/
function stopCoverage(): void;
}
declare module 'node:v8' {
export * from 'v8';

424
packages/node_modules/@node-red/editor-client/src/types/node/vm.d.ts vendored
View File

@ -1,8 +1,44 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `vm` module enables compiling and running code within V8 Virtual
* Machine contexts. **The `vm` module is not a security mechanism. Do**
* **not use it to run untrusted code.**
*
* JavaScript code can be compiled and run immediately or
* compiled, saved, and run later.
*
* A common use case is to run the code in a different V8 Context. This means
* invoked code has a different global object than the invoking code.
*
* One can provide the context by `contextifying` an
* object. The invoked code treats any property in the context like a
* global variable. Any changes to global variables caused by the invoked
* code are reflected in the context object.
*
* ```js
* const vm = require('vm');
*
* const x = 1;
*
* const context = { x: 2 };
* vm.createContext(context); // Contextify the object.
*
* const code = 'x += 40; var y = 17;';
* // `x` and `y` are global variables in the context.
* // Initially, x has the value 2 because that is the value of context.x.
* vm.runInContext(code, context);
*
* console.log(context.x); // 42
* console.log(context.y); // 17
*
* console.log(x); // 1; y is not defined.
* ```
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/vm.js)
*/
declare module 'vm' {
interface Context extends NodeJS.Dict<any> { }
interface Context extends NodeJS.Dict<any> {}
interface BaseOptions {
/**
* Specifies the filename used in stack traces produced by this script.
@ -64,13 +100,11 @@ declare module 'vm' {
* The sandbox/context in which the said function should be compiled in.
*/
parsingContext?: Context | undefined;
/**
* An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
*/
contextExtensions?: Object[] | undefined;
}
interface CreateContextOptions {
/**
* Human-readable name of the newly created context.
@ -85,27 +119,27 @@ declare module 'vm' {
* @default ''
*/
origin?: string | undefined;
codeGeneration?: {
/**
* If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc)
* will throw an EvalError.
* @default true
*/
strings?: boolean | undefined;
/**
* If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError.
* @default true
*/
wasm?: boolean | undefined;
} | undefined;
codeGeneration?:
| {
/**
* If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc)
* will throw an EvalError.
* @default true
*/
strings?: boolean | undefined;
/**
* If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError.
* @default true
*/
wasm?: boolean | undefined;
}
| undefined;
/**
* If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
*/
microtaskMode?: 'afterEvaluate' | undefined;
}
type MeasureMemoryMode = 'summary' | 'detailed';
interface MeasureMemoryOptions {
/**
* @default 'summary'
@ -113,42 +147,360 @@ declare module 'vm' {
mode?: MeasureMemoryMode | undefined;
context?: Context | undefined;
}
interface MemoryMeasurement {
total: {
jsMemoryEstimate: number;
jsMemoryRange: [number, number];
};
}
/**
* Instances of the `vm.Script` class contain precompiled scripts that can be
* executed in specific contexts.
* @since v0.3.1
*/
class Script {
constructor(code: string, options?: ScriptOptions);
runInContext(contextifiedSandbox: Context, options?: RunningScriptOptions): any;
runInNewContext(sandbox?: Context, options?: RunningScriptOptions): any;
/**
* Runs the compiled code contained by the `vm.Script` object within the given`contextifiedObject` and returns the result. Running code does not have access
* to local scope.
*
* The following example compiles code that increments a global variable, sets
* the value of another global variable, then execute the code multiple times.
* The globals are contained in the `context` object.
*
* ```js
* const vm = require('vm');
*
* const context = {
* animal: 'cat',
* count: 2
* };
*
* const script = new vm.Script('count += 1; name = "kitty";');
*
* vm.createContext(context);
* for (let i = 0; i < 10; ++i) {
* script.runInContext(context);
* }
*
* console.log(context);
* // Prints: { animal: 'cat', count: 12, name: 'kitty' }
* ```
*
* Using the `timeout` or `breakOnSigint` options will result in new event loops
* and corresponding threads being started, which have a non-zero performance
* overhead.
* @since v0.3.1
* @param contextifiedObject A `contextified` object as returned by the `vm.createContext()` method.
* @return the result of the very last statement executed in the script.
*/
runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
/**
* First contextifies the given `contextObject`, runs the compiled code contained
* by the `vm.Script` object within the created context, and returns the result.
* Running code does not have access to local scope.
*
* The following example compiles code that sets a global variable, then executes
* the code multiple times in different contexts. The globals are set on and
* contained within each individual `context`.
*
* ```js
* const vm = require('vm');
*
* const script = new vm.Script('globalVar = "set"');
*
* const contexts = [{}, {}, {}];
* contexts.forEach((context) => {
* script.runInNewContext(context);
* });
*
* console.log(contexts);
* // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]
* ```
* @since v0.3.1
* @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
* @return the result of the very last statement executed in the script.
*/
runInNewContext(contextObject?: Context, options?: RunningScriptOptions): any;
/**
* Runs the compiled code contained by the `vm.Script` within the context of the
* current `global` object. Running code does not have access to local scope, but_does_ have access to the current `global` object.
*
* The following example compiles code that increments a `global` variable then
* executes that code multiple times:
*
* ```js
* const vm = require('vm');
*
* global.globalVar = 0;
*
* const script = new vm.Script('globalVar += 1', { filename: 'myfile.vm' });
*
* for (let i = 0; i < 1000; ++i) {
* script.runInThisContext();
* }
*
* console.log(globalVar);
*
* // 1000
* ```
* @since v0.3.1
* @return the result of the very last statement executed in the script.
*/
runInThisContext(options?: RunningScriptOptions): any;
/**
* Creates a code cache that can be used with the `Script` constructor's`cachedData` option. Returns a `Buffer`. This method may be called at any
* time and any number of times.
*
* ```js
* const script = new vm.Script(`
* function add(a, b) {
* return a + b;
* }
*
* const x = add(1, 2);
* `);
*
* const cacheWithoutX = script.createCachedData();
*
* script.runInThisContext();
*
* const cacheWithX = script.createCachedData();
* ```
* @since v10.6.0
*/
createCachedData(): Buffer;
/** @deprecated in favor of `script.createCachedData()` */
cachedDataProduced?: boolean | undefined;
cachedDataRejected?: boolean | undefined;
cachedData?: Buffer | undefined;
}
function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
function isContext(sandbox: Context): boolean;
function runInContext(code: string, contextifiedSandbox: Context, options?: RunningScriptOptions | string): any;
function runInNewContext(code: string, sandbox?: Context, options?: RunningScriptOptions | string): any;
function runInThisContext(code: string, options?: RunningScriptOptions | string): any;
function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): Function;
/**
* Measure the memory known to V8 and used by the current execution context or a specified context.
* If given a `contextObject`, the `vm.createContext()` method will `prepare
* that object` so that it can be used in calls to {@link runInContext} or `script.runInContext()`. Inside such scripts,
* the `contextObject` will be the global object, retaining all of its existing
* properties but also having the built-in objects and functions any standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global variables
* will remain unchanged.
*
* ```js
* const vm = require('vm');
*
* global.globalVar = 3;
*
* const context = { globalVar: 1 };
* vm.createContext(context);
*
* vm.runInContext('globalVar *= 2;', context);
*
* console.log(context);
* // Prints: { globalVar: 2 }
*
* console.log(global.globalVar);
* // Prints: 3
* ```
*
* If `contextObject` is omitted (or passed explicitly as `undefined`), a new,
* empty `contextified` object will be returned.
*
* The `vm.createContext()` method is primarily useful for creating a single
* context that can be used to run multiple scripts. For instance, if emulating a
* web browser, the method can be used to create a single context representing a
* window's global object, then run all `<script>` tags together within that
* context.
*
* The provided `name` and `origin` of the context are made visible through the
* Inspector API.
* @since v0.3.1
* @return contextified object.
*/
function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
/**
* Returns `true` if the given `object` object has been `contextified` using {@link createContext}.
* @since v0.11.7
*/
function isContext(sandbox: Context): boolean;
/**
* The `vm.runInContext()` method compiles `code`, runs it within the context of
* the `contextifiedObject`, then returns the result. Running code does not have
* access to the local scope. The `contextifiedObject` object _must_ have been
* previously `contextified` using the {@link createContext} method.
*
* If `options` is a string, then it specifies the filename.
*
* The following example compiles and executes different scripts using a single `contextified` object:
*
* ```js
* const vm = require('vm');
*
* const contextObject = { globalVar: 1 };
* vm.createContext(contextObject);
*
* for (let i = 0; i < 10; ++i) {
* vm.runInContext('globalVar *= 2;', contextObject);
* }
* console.log(contextObject);
* // Prints: { globalVar: 1024 }
* ```
* @since v0.3.1
* @param code The JavaScript code to compile and run.
* @param contextifiedObject The `contextified` object that will be used as the `global` when the `code` is compiled and run.
* @return the result of the very last statement executed in the script.
*/
function runInContext(code: string, contextifiedObject: Context, options?: RunningScriptOptions | string): any;
/**
* The `vm.runInNewContext()` first contextifies the given `contextObject` (or
* creates a new `contextObject` if passed as `undefined`), compiles the `code`,
* runs it within the created context, then returns the result. Running code
* does not have access to the local scope.
*
* If `options` is a string, then it specifies the filename.
*
* The following example compiles and executes code that increments a global
* variable and sets a new one. These globals are contained in the `contextObject`.
*
* ```js
* const vm = require('vm');
*
* const contextObject = {
* animal: 'cat',
* count: 2
* };
*
* vm.runInNewContext('count += 1; name = "kitty"', contextObject);
* console.log(contextObject);
* // Prints: { animal: 'cat', count: 3, name: 'kitty' }
* ```
* @since v0.3.1
* @param code The JavaScript code to compile and run.
* @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
* @return the result of the very last statement executed in the script.
*/
function runInNewContext(code: string, contextObject?: Context, options?: RunningScriptOptions | string): any;
/**
* `vm.runInThisContext()` compiles `code`, runs it within the context of the
* current `global` and returns the result. Running code does not have access to
* local scope, but does have access to the current `global` object.
*
* If `options` is a string, then it specifies the filename.
*
* The following example illustrates using both `vm.runInThisContext()` and
* the JavaScript [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) function to run the same code:
*
* ```js
* const vm = require('vm');
* let localVar = 'initial value';
*
* const vmResult = vm.runInThisContext('localVar = "vm";');
* console.log(`vmResult: '${vmResult}', localVar: '${localVar}'`);
* // Prints: vmResult: 'vm', localVar: 'initial value'
*
* const evalResult = eval('localVar = "eval";');
* console.log(`evalResult: '${evalResult}', localVar: '${localVar}'`);
* // Prints: evalResult: 'eval', localVar: 'eval'
* ```
*
* Because `vm.runInThisContext()` does not have access to the local scope,`localVar` is unchanged. In contrast,
* [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) _does_ have access to the
* local scope, so the value `localVar` is changed. In this way`vm.runInThisContext()` is much like an [indirect `eval()` call](https://es5.github.io/#x10.4.2), e.g.`(0,eval)('code')`.
*
* ## Example: Running an HTTP server within a VM
*
* When using either `script.runInThisContext()` or {@link runInThisContext}, the code is executed within the current V8 global
* context. The code passed to this VM context will have its own isolated scope.
*
* In order to run a simple web server using the `http` module the code passed to
* the context must either call `require('http')` on its own, or have a reference
* to the `http` module passed to it. For instance:
*
* ```js
* 'use strict';
* const vm = require('vm');
*
* const code = `
* ((require) => {
* const http = require('http');
*
* http.createServer((request, response) => {
* response.writeHead(200, { 'Content-Type': 'text/plain' });
* response.end('Hello World\\n');
* }).listen(8124);
*
* console.log('Server running at http://127.0.0.1:8124/');
* })`;
*
* vm.runInThisContext(code)(require);
* ```
*
* The `require()` in the above case shares the state with the context it is
* passed from. This may introduce risks when untrusted code is executed, e.g.
* altering objects in the context in unwanted ways.
* @since v0.3.1
* @param code The JavaScript code to compile and run.
* @return the result of the very last statement executed in the script.
*/
function runInThisContext(code: string, options?: RunningScriptOptions | string): any;
/**
* Compiles the given code into the provided context (if no context is
* supplied, the current context is used), and returns it wrapped inside a
* function with the given `params`.
* @since v10.10.0
* @param code The body of the function to compile.
* @param params An array of strings containing all parameters for the function.
*/
function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): Function;
/**
* Measure the memory known to V8 and used by all contexts known to the
* current V8 isolate, or the main context.
*
* The format of the object that the returned Promise may resolve with is
* specific to the V8 engine and may change from one version of V8 to the next.
*
* The returned result is different from the statistics returned by
* `v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measures
* the memory reachable by V8 from a specific context, while
* `v8.getHeapSpaceStatistics()` measures the memory used by an instance
* of V8 engine, which can switch among multiple contexts that reference
* objects in the heap of one engine.
* The returned result is different from the statistics returned by`v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measure the
* memory reachable by each V8 specific contexts in the current instance of
* the V8 engine, while the result of `v8.getHeapSpaceStatistics()` measure
* the memory occupied by each heap space in the current V8 instance.
*
* ```js
* const vm = require('vm');
* // Measure the memory used by the main context.
* vm.measureMemory({ mode: 'summary' })
* // This is the same as vm.measureMemory()
* .then((result) => {
* // The current format is:
* // {
* // total: {
* // jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]
* // }
* // }
* console.log(result);
* });
*
* const context = vm.createContext({ a: 1 });
* vm.measureMemory({ mode: 'detailed', execution: 'eager' })
* .then((result) => {
* // Reference the context here so that it won't be GC'ed
* // until the measurement is complete.
* console.log(context.a);
* // {
* // total: {
* // jsMemoryEstimate: 2574732,
* // jsMemoryRange: [ 2574732, 2904372 ]
* // },
* // current: {
* // jsMemoryEstimate: 2438996,
* // jsMemoryRange: [ 2438996, 2768636 ]
* // },
* // other: [
* // {
* // jsMemoryEstimate: 135736,
* // jsMemoryRange: [ 135736, 465376 ]
* // }
* // ]
* // }
* console.log(result);
* });
* ```
* @since v13.10.0
* @experimental
*/
function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;

115
packages/node_modules/@node-red/editor-client/src/types/node/wasi.d.ts vendored
View File

@ -1,6 +1,78 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The WASI API provides an implementation of the [WebAssembly System Interface](https://wasi.dev/) specification. WASI gives sandboxed WebAssembly applications access to the
* underlying operating system via a collection of POSIX-like functions.
*
* ```js
* import { readFile } from 'fs/promises';
* import { WASI } from 'wasi';
* import { argv, env } from 'process';
*
* const wasi = new WASI({
* args: argv,
* env,
* preopens: {
* '/sandbox': '/some/real/path/that/wasm/can/access'
* }
* });
*
* // Some WASI binaries require:
* // const importObject = { wasi_unstable: wasi.wasiImport };
* const importObject = { wasi_snapshot_preview1: wasi.wasiImport };
*
* const wasm = await WebAssembly.compile(
* await readFile(new URL('./demo.wasm', import.meta.url))
* );
* const instance = await WebAssembly.instantiate(wasm, importObject);
*
* wasi.start(instance);
* ```
*
* To run the above example, create a new WebAssembly text format file named`demo.wat`:
*
* ```text
* (module
* ;; Import the required fd_write WASI function which will write the given io vectors to stdout
* ;; The function signature for fd_write is:
* ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written
* (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
*
* (memory 1)
* (export "memory" (memory 0))
*
* ;; Write 'hello world\n' to memory at an offset of 8 bytes
* ;; Note the trailing newline which is required for the text to appear
* (data (i32.const 8) "hello world\n")
*
* (func $main (export "_start")
* ;; Creating a new io vector within linear memory
* (i32.store (i32.const 0) (i32.const 8)) ;; iov.iov_base - This is a pointer to the start of the 'hello world\n' string
* (i32.store (i32.const 4) (i32.const 12)) ;; iov.iov_len - The length of the 'hello world\n' string
*
* (call $fd_write
* (i32.const 1) ;; file_descriptor - 1 for stdout
* (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0
* (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.
* (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written
* )
* drop ;; Discard the number of bytes written from the top of the stack
* )
* )
* ```
*
* Use [wabt](https://github.com/WebAssembly/wabt) to compile `.wat` to `.wasm`
*
* ```console
* $ wat2wasm demo.wat
* ```
*
* The `--experimental-wasi-unstable-preview1` CLI argument is needed for this
* example to run.
* @experimental
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/wasi.js)
*/
declare module 'wasi' {
interface WASIOptions {
/**
@ -9,13 +81,11 @@ declare module 'wasi' {
* WASI command itself.
*/
args?: string[] | undefined;
/**
* An object similar to `process.env` that the WebAssembly
* application will see as its environment.
*/
env?: object | undefined;
/**
* This object represents the WebAssembly application's
* sandbox directory structure. The string keys of `preopens` are treated as
@ -23,7 +93,6 @@ declare module 'wasi' {
* the real paths to those directories on the host machine.
*/
preopens?: NodeJS.Dict<string> | undefined;
/**
* By default, WASI applications terminate the Node.js
* process via the `__wasi_proc_exit()` function. Setting this option to `true`
@ -32,57 +101,57 @@ declare module 'wasi' {
* @default false
*/
returnOnExit?: boolean | undefined;
/**
* The file descriptor used as standard input in the WebAssembly application.
* @default 0
*/
stdin?: number | undefined;
/**
* The file descriptor used as standard output in the WebAssembly application.
* @default 1
*/
stdout?: number | undefined;
/**
* The file descriptor used as standard error in the WebAssembly application.
* @default 2
*/
stderr?: number | undefined;
}
/**
* The `WASI` class provides the WASI system call API and additional convenience
* methods for working with WASI-based applications. Each `WASI` instance
* represents a distinct sandbox environment. For security purposes, each `WASI`instance must have its command-line arguments, environment variables, and
* sandbox directory structure configured explicitly.
* @since v13.3.0, v12.16.0
*/
class WASI {
constructor(options?: WASIOptions);
/**
* Attempt to begin execution of `instance` as a WASI command by invoking its`_start()` export. If `instance` does not contain a `_start()` export, or if`instance` contains an `_initialize()`
* export, then an exception is thrown.
*
* Attempt to begin execution of `instance` by invoking its `_start()` export.
* If `instance` does not contain a `_start()` export, then `start()` attempts to
* invoke the `__wasi_unstable_reactor_start()` export. If neither of those exports
* is present on `instance`, then `start()` does nothing.
*
* `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
* `memory`. If `instance` does not have a `memory` export an exception is thrown.
* `start()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`. If
* `instance` does not have a `memory` export an exception is thrown.
*
* If `start()` is called more than once, an exception is thrown.
* @since v13.3.0, v12.16.0
*/
start(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
/**
* Attempt to initialize `instance` as a WASI reactor by invoking its `_initialize()` export, if it is present.
* If `instance` contains a `_start()` export, then an exception is thrown.
* Attempt to initialize `instance` as a WASI reactor by invoking its`_initialize()` export, if it is present. If `instance` contains a `_start()`export, then an exception is thrown.
*
* `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
* `memory`. If `instance` does not have a `memory` export an exception is thrown.
* `initialize()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`.
* If `instance` does not have a `memory` export an exception is thrown.
*
* If `initialize()` is called more than once, an exception is thrown.
* @since v14.6.0, v12.19.0
*/
initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
/**
* Is an object that implements the WASI system call API. This object
* should be passed as the `wasi_snapshot_preview1` import during the instantiation of a
* [`WebAssembly.Instance`][].
* `wasiImport` is an object that implements the WASI system call API. This object
* should be passed as the `wasi_snapshot_preview1` import during the instantiation
* of a [`WebAssembly.Instance`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance).
* @since v13.3.0, v12.16.0
*/
readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
}

654
packages/node_modules/@node-red/editor-client/src/types/node/worker_threads.d.ts vendored
View File

@ -1,75 +1,246 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `worker_threads` module enables the use of threads that execute JavaScript
* in parallel. To access it:
*
* ```js
* const worker = require('worker_threads');
* ```
*
* Workers (threads) are useful for performing CPU-intensive JavaScript operations.
* They do not help much with I/O-intensive work. The Node.js built-in
* asynchronous I/O operations are more efficient than Workers can be.
*
* Unlike `child_process` or `cluster`, `worker_threads` can share memory. They do
* so by transferring `ArrayBuffer` instances or sharing `SharedArrayBuffer`instances.
*
* ```js
* const {
* Worker, isMainThread, parentPort, workerData
* } = require('worker_threads');
*
* if (isMainThread) {
* module.exports = function parseJSAsync(script) {
* return new Promise((resolve, reject) => {
* const worker = new Worker(__filename, {
* workerData: script
* });
* worker.on('message', resolve);
* worker.on('error', reject);
* worker.on('exit', (code) => {
* if (code !== 0)
* reject(new Error(`Worker stopped with exit code ${code}`));
* });
* });
* };
* } else {
* const { parse } = require('some-js-parsing-library');
* const script = workerData;
* parentPort.postMessage(parse(script));
* }
* ```
*
* The above example spawns a Worker thread for each `parse()` call. In actual
* practice, use a pool of Workers for these kinds of tasks. Otherwise, the
* overhead of creating Workers would likely exceed their benefit.
*
* When implementing a worker pool, use the `AsyncResource` API to inform
* diagnostic tools (e.g. to provide asynchronous stack traces) about the
* correlation between tasks and their outcomes. See `"Using AsyncResource for a Worker thread pool"` in the `async_hooks` documentation for an example implementation.
*
* Worker threads inherit non-process-specific options by default. Refer to `Worker constructor options` to know how to customize worker thread options,
* specifically `argv` and `execArgv` options.
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/worker_threads.js)
*/
declare module 'worker_threads' {
import { Context } from 'vm';
import EventEmitter = require('events');
import { Readable, Writable } from 'stream';
import { URL } from 'url';
import { FileHandle } from 'fs/promises';
import { Blob } from 'node:buffer';
import { Context } from 'node:vm';
import { EventEmitter } from 'node:events';
import { EventLoopUtilityFunction } from 'node:perf_hooks';
import { FileHandle } from 'node:fs/promises';
import { Readable, Writable } from 'node:stream';
import { URL } from 'node:url';
import { X509Certificate } from 'node:crypto';
const isMainThread: boolean;
const parentPort: null | MessagePort;
const resourceLimits: ResourceLimits;
const SHARE_ENV: unique symbol;
const threadId: number;
const workerData: any;
/**
* Instances of the `worker.MessageChannel` class represent an asynchronous,
* two-way communications channel.
* The `MessageChannel` has no methods of its own. `new MessageChannel()`yields an object with `port1` and `port2` properties, which refer to linked `MessagePort` instances.
*
* ```js
* const { MessageChannel } = require('worker_threads');
*
* const { port1, port2 } = new MessageChannel();
* port1.on('message', (message) => console.log('received', message));
* port2.postMessage({ foo: 'bar' });
* // Prints: received { foo: 'bar' } from the `port1.on('message')` listener
* ```
* @since v10.5.0
*/
class MessageChannel {
readonly port1: MessagePort;
readonly port2: MessagePort;
}
type TransferListItem = ArrayBuffer | MessagePort | FileHandle;
interface WorkerPerformance {
eventLoopUtilization: EventLoopUtilityFunction;
}
type TransferListItem = ArrayBuffer | MessagePort | FileHandle | X509Certificate | Blob;
/**
* Instances of the `worker.MessagePort` class represent one end of an
* asynchronous, two-way communications channel. It can be used to transfer
* structured data, memory regions and other `MessagePort`s between different `Worker` s.
*
* This implementation matches [browser `MessagePort`](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort) s.
* @since v10.5.0
*/
class MessagePort extends EventEmitter {
/**
* Disables further sending of messages on either side of the connection.
* This method can be called when no further communication will happen over this`MessagePort`.
*
* The `'close' event` is emitted on both `MessagePort` instances that
* are part of the channel.
* @since v10.5.0
*/
close(): void;
/**
* Sends a JavaScript value to the receiving side of this channel.`value` is transferred in a way which is compatible with
* the [HTML structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
*
* In particular, the significant differences to `JSON` are:
*
* * `value` may contain circular references.
* * `value` may contain instances of builtin JS types such as `RegExp`s,`BigInt`s, `Map`s, `Set`s, etc.
* * `value` may contain typed arrays, both using `ArrayBuffer`s
* and `SharedArrayBuffer`s.
* * `value` may contain [`WebAssembly.Module`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module) instances.
* * `value` may not contain native (C++-backed) objects other than:
*
* ```js
* const { MessageChannel } = require('worker_threads');
* const { port1, port2 } = new MessageChannel();
*
* port1.on('message', (message) => console.log(message));
*
* const circularData = {};
* circularData.foo = circularData;
* // Prints: { foo: [Circular] }
* port2.postMessage(circularData);
* ```
*
* `transferList` may be a list of [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), `MessagePort` and `FileHandle` objects.
* After transferring, they are not usable on the sending side of the channel
* anymore (even if they are not contained in `value`). Unlike with `child processes`, transferring handles such as network sockets is currently
* not supported.
*
* If `value` contains [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) instances, those are accessible
* from either thread. They cannot be listed in `transferList`.
*
* `value` may still contain `ArrayBuffer` instances that are not in`transferList`; in that case, the underlying memory is copied rather than moved.
*
* ```js
* const { MessageChannel } = require('worker_threads');
* const { port1, port2 } = new MessageChannel();
*
* port1.on('message', (message) => console.log(message));
*
* const uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);
* // This posts a copy of `uint8Array`:
* port2.postMessage(uint8Array);
* // This does not copy data, but renders `uint8Array` unusable:
* port2.postMessage(uint8Array, [ uint8Array.buffer ]);
*
* // The memory for the `sharedUint8Array` is accessible from both the
* // original and the copy received by `.on('message')`:
* const sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));
* port2.postMessage(sharedUint8Array);
*
* // This transfers a freshly created message port to the receiver.
* // This can be used, for example, to create communication channels between
* // multiple `Worker` threads that are children of the same parent thread.
* const otherChannel = new MessageChannel();
* port2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]);
* ```
*
* The message object is cloned immediately, and can be modified after
* posting without having side effects.
*
* For more information on the serialization and deserialization mechanisms
* behind this API, see the `serialization API of the v8 module`.
* @since v10.5.0
*/
postMessage(value: any, transferList?: ReadonlyArray<TransferListItem>): void;
/**
* Opposite of `unref()`. Calling `ref()` on a previously `unref()`ed port does_not_ let the program exit if it's the only active handle left (the default
* behavior). If the port is `ref()`ed, calling `ref()` again has no effect.
*
* If listeners are attached or removed using `.on('message')`, the port
* is `ref()`ed and `unref()`ed automatically depending on whether
* listeners for the event exist.
* @since v10.5.0
*/
ref(): void;
/**
* Calling `unref()` on a port allows the thread to exit if this is the only
* active handle in the event system. If the port is already `unref()`ed calling`unref()` again has no effect.
*
* If listeners are attached or removed using `.on('message')`, the port is`ref()`ed and `unref()`ed automatically depending on whether
* listeners for the event exist.
* @since v10.5.0
*/
unref(): void;
/**
* Starts receiving messages on this `MessagePort`. When using this port
* as an event emitter, this is called automatically once `'message'`listeners are attached.
*
* This method exists for parity with the Web `MessagePort` API. In Node.js,
* it is only useful for ignoring messages when no event listener is present.
* Node.js also diverges in its handling of `.onmessage`. Setting it
* automatically calls `.start()`, but unsetting it lets messages queue up
* until a new handler is set or the port is discarded.
* @since v10.5.0
*/
start(): void;
addListener(event: "close", listener: () => void): this;
addListener(event: "message", listener: (value: any) => void): this;
addListener(event: "messageerror", listener: (error: Error) => void): this;
addListener(event: 'close', listener: () => void): this;
addListener(event: 'message', listener: (value: any) => void): this;
addListener(event: 'messageerror', listener: (error: Error) => void): this;
addListener(event: string | symbol, listener: (...args: any[]) => void): this;
emit(event: "close"): boolean;
emit(event: "message", value: any): boolean;
emit(event: "messageerror", error: Error): boolean;
emit(event: 'close'): boolean;
emit(event: 'message', value: any): boolean;
emit(event: 'messageerror', error: Error): boolean;
emit(event: string | symbol, ...args: any[]): boolean;
on(event: "close", listener: () => void): this;
on(event: "message", listener: (value: any) => void): this;
on(event: "messageerror", listener: (error: Error) => void): this;
on(event: 'close', listener: () => void): this;
on(event: 'message', listener: (value: any) => void): this;
on(event: 'messageerror', listener: (error: Error) => void): this;
on(event: string | symbol, listener: (...args: any[]) => void): this;
once(event: "close", listener: () => void): this;
once(event: "message", listener: (value: any) => void): this;
once(event: "messageerror", listener: (error: Error) => void): this;
once(event: 'close', listener: () => void): this;
once(event: 'message', listener: (value: any) => void): this;
once(event: 'messageerror', listener: (error: Error) => void): this;
once(event: string | symbol, listener: (...args: any[]) => void): this;
prependListener(event: "close", listener: () => void): this;
prependListener(event: "message", listener: (value: any) => void): this;
prependListener(event: "messageerror", listener: (error: Error) => void): this;
prependListener(event: 'close', listener: () => void): this;
prependListener(event: 'message', listener: (value: any) => void): this;
prependListener(event: 'messageerror', listener: (error: Error) => void): this;
prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
prependOnceListener(event: "close", listener: () => void): this;
prependOnceListener(event: "message", listener: (value: any) => void): this;
prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
prependOnceListener(event: 'close', listener: () => void): this;
prependOnceListener(event: 'message', listener: (value: any) => void): this;
prependOnceListener(event: 'messageerror', listener: (error: Error) => void): this;
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
removeListener(event: "close", listener: () => void): this;
removeListener(event: "message", listener: (value: any) => void): this;
removeListener(event: "messageerror", listener: (error: Error) => void): this;
removeListener(event: 'close', listener: () => void): this;
removeListener(event: 'message', listener: (value: any) => void): this;
removeListener(event: 'messageerror', listener: (error: Error) => void): this;
removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
off(event: "close", listener: () => void): this;
off(event: "message", listener: (value: any) => void): this;
off(event: "messageerror", listener: (error: Error) => void): this;
off(event: 'close', listener: () => void): this;
off(event: 'message', listener: (value: any) => void): this;
off(event: 'messageerror', listener: (error: Error) => void): this;
off(event: string | symbol, listener: (...args: any[]) => void): this;
}
interface WorkerOptions {
/**
* List of arguments which would be stringified and appended to
@ -90,9 +261,11 @@ declare module 'worker_threads' {
* Additional data to send in the first worker message.
*/
transferList?: TransferListItem[] | undefined;
/**
* @default true
*/
trackUnmanagedFds?: boolean | undefined;
}
interface ResourceLimits {
/**
* The maximum size of a heap space for recently created objects.
@ -112,132 +285,367 @@ declare module 'worker_threads' {
*/
stackSizeMb?: number | undefined;
}
/**
* The `Worker` class represents an independent JavaScript execution thread.
* Most Node.js APIs are available inside of it.
*
* Notable differences inside a Worker environment are:
*
* * The `process.stdin`, `process.stdout` and `process.stderr` may be redirected by the parent thread.
* * The `require('worker_threads').isMainThread` property is set to `false`.
* * The `require('worker_threads').parentPort` message port is available.
* * `process.exit()` does not stop the whole program, just the single thread,
* and `process.abort()` is not available.
* * `process.chdir()` and `process` methods that set group or user ids
* are not available.
* * `process.env` is a copy of the parent thread's environment variables,
* unless otherwise specified. Changes to one copy are not visible in other
* threads, and are not visible to native add-ons (unless `worker.SHARE_ENV` is passed as the `env` option to the `Worker` constructor).
* * `process.title` cannot be modified.
* * Signals are not delivered through `process.on('...')`.
* * Execution may stop at any point as a result of `worker.terminate()` being invoked.
* * IPC channels from parent processes are not accessible.
* * The `trace_events` module is not supported.
* * Native add-ons can only be loaded from multiple threads if they fulfill `certain conditions`.
*
* Creating `Worker` instances inside of other `Worker`s is possible.
*
* Like [Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) and the `cluster module`, two-way communication can be
* achieved through inter-thread message passing. Internally, a `Worker` has a
* built-in pair of `MessagePort` s that are already associated with each other
* when the `Worker` is created. While the `MessagePort` object on the parent side
* is not directly exposed, its functionalities are exposed through `worker.postMessage()` and the `worker.on('message')` event
* on the `Worker` object for the parent thread.
*
* To create custom messaging channels (which is encouraged over using the default
* global channel because it facilitates separation of concerns), users can create
* a `MessageChannel` object on either thread and pass one of the`MessagePort`s on that `MessageChannel` to the other thread through a
* pre-existing channel, such as the global one.
*
* See `port.postMessage()` for more information on how messages are passed,
* and what kind of JavaScript values can be successfully transported through
* the thread barrier.
*
* ```js
* const assert = require('assert');
* const {
* Worker, MessageChannel, MessagePort, isMainThread, parentPort
* } = require('worker_threads');
* if (isMainThread) {
* const worker = new Worker(__filename);
* const subChannel = new MessageChannel();
* worker.postMessage({ hereIsYourPort: subChannel.port1 }, [subChannel.port1]);
* subChannel.port2.on('message', (value) => {
* console.log('received:', value);
* });
* } else {
* parentPort.once('message', (value) => {
* assert(value.hereIsYourPort instanceof MessagePort);
* value.hereIsYourPort.postMessage('the worker is sending this');
* value.hereIsYourPort.close();
* });
* }
* ```
* @since v10.5.0
*/
class Worker extends EventEmitter {
/**
* If `stdin: true` was passed to the `Worker` constructor, this is a
* writable stream. The data written to this stream will be made available in
* the worker thread as `process.stdin`.
* @since v10.5.0
*/
readonly stdin: Writable | null;
/**
* This is a readable stream which contains data written to `process.stdout` inside the worker thread. If `stdout: true` was not passed to the `Worker` constructor, then data is piped to the
* parent thread's `process.stdout` stream.
* @since v10.5.0
*/
readonly stdout: Readable;
/**
* This is a readable stream which contains data written to `process.stderr` inside the worker thread. If `stderr: true` was not passed to the `Worker` constructor, then data is piped to the
* parent thread's `process.stderr` stream.
* @since v10.5.0
*/
readonly stderr: Readable;
/**
* An integer identifier for the referenced thread. Inside the worker thread,
* it is available as `require('worker_threads').threadId`.
* This value is unique for each `Worker` instance inside a single process.
* @since v10.5.0
*/
readonly threadId: number;
/**
* Provides the set of JS engine resource constraints for this Worker thread.
* If the `resourceLimits` option was passed to the `Worker` constructor,
* this matches its values.
*
* If the worker has stopped, the return value is an empty object.
* @since v13.2.0, v12.16.0
*/
readonly resourceLimits?: ResourceLimits | undefined;
/**
* An object that can be used to query performance information from a worker
* instance. Similar to `perf_hooks.performance`.
* @since v15.1.0, v12.22.0
*/
readonly performance: WorkerPerformance;
/**
* @param filename The path to the Worker’s main script or module.
* Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with ./ or ../,
* or a WHATWG URL object using file: protocol. If options.eval is true, this is a string containing JavaScript code rather than a path.
*/
constructor(filename: string | URL, options?: WorkerOptions);
/**
* Send a message to the worker that is received via `require('worker_threads').parentPort.on('message')`.
* See `port.postMessage()` for more details.
* @since v10.5.0
*/
postMessage(value: any, transferList?: ReadonlyArray<TransferListItem>): void;
/**
* Opposite of `unref()`, calling `ref()` on a previously `unref()`ed worker does_not_ let the program exit if it's the only active handle left (the default
* behavior). If the worker is `ref()`ed, calling `ref()` again has
* no effect.
* @since v10.5.0
*/
ref(): void;
/**
* Calling `unref()` on a worker allows the thread to exit if this is the only
* active handle in the event system. If the worker is already `unref()`ed calling`unref()` again has no effect.
* @since v10.5.0
*/
unref(): void;
/**
* Stop all JavaScript execution in the worker thread as soon as possible.
* Returns a Promise for the exit code that is fulfilled when the `exit` event is emitted.
* Returns a Promise for the exit code that is fulfilled when the `'exit' event` is emitted.
* @since v10.5.0
*/
terminate(): Promise<number>;
/**
* Returns a readable stream for a V8 snapshot of the current state of the Worker.
* See [`v8.getHeapSnapshot()`][] for more details.
* See `v8.getHeapSnapshot()` for more details.
*
* If the Worker thread is no longer running, which may occur before the
* [`'exit'` event][] is emitted, the returned `Promise` will be rejected
* immediately with an [`ERR_WORKER_NOT_RUNNING`][] error
* If the Worker thread is no longer running, which may occur before the `'exit' event` is emitted, the returned `Promise` is rejected
* immediately with an `ERR_WORKER_NOT_RUNNING` error.
* @since v13.9.0, v12.17.0
* @return A promise for a Readable Stream containing a V8 heap snapshot
*/
getHeapSnapshot(): Promise<Readable>;
addListener(event: "error", listener: (err: Error) => void): this;
addListener(event: "exit", listener: (exitCode: number) => void): this;
addListener(event: "message", listener: (value: any) => void): this;
addListener(event: "messageerror", listener: (error: Error) => void): this;
addListener(event: "online", listener: () => void): this;
addListener(event: 'error', listener: (err: Error) => void): this;
addListener(event: 'exit', listener: (exitCode: number) => void): this;
addListener(event: 'message', listener: (value: any) => void): this;
addListener(event: 'messageerror', listener: (error: Error) => void): this;
addListener(event: 'online', listener: () => void): this;
addListener(event: string | symbol, listener: (...args: any[]) => void): this;
emit(event: "error", err: Error): boolean;
emit(event: "exit", exitCode: number): boolean;
emit(event: "message", value: any): boolean;
emit(event: "messageerror", error: Error): boolean;
emit(event: "online"): boolean;
emit(event: 'error', err: Error): boolean;
emit(event: 'exit', exitCode: number): boolean;
emit(event: 'message', value: any): boolean;
emit(event: 'messageerror', error: Error): boolean;
emit(event: 'online'): boolean;
emit(event: string | symbol, ...args: any[]): boolean;
on(event: "error", listener: (err: Error) => void): this;
on(event: "exit", listener: (exitCode: number) => void): this;
on(event: "message", listener: (value: any) => void): this;
on(event: "messageerror", listener: (error: Error) => void): this;
on(event: "online", listener: () => void): this;
on(event: 'error', listener: (err: Error) => void): this;
on(event: 'exit', listener: (exitCode: number) => void): this;
on(event: 'message', listener: (value: any) => void): this;
on(event: 'messageerror', listener: (error: Error) => void): this;
on(event: 'online', listener: () => void): this;
on(event: string | symbol, listener: (...args: any[]) => void): this;
once(event: "error", listener: (err: Error) => void): this;
once(event: "exit", listener: (exitCode: number) => void): this;
once(event: "message", listener: (value: any) => void): this;
once(event: "messageerror", listener: (error: Error) => void): this;
once(event: "online", listener: () => void): this;
once(event: 'error', listener: (err: Error) => void): this;
once(event: 'exit', listener: (exitCode: number) => void): this;
once(event: 'message', listener: (value: any) => void): this;
once(event: 'messageerror', listener: (error: Error) => void): this;
once(event: 'online', listener: () => void): this;
once(event: string | symbol, listener: (...args: any[]) => void): this;
prependListener(event: "error", listener: (err: Error) => void): this;
prependListener(event: "exit", listener: (exitCode: number) => void): this;
prependListener(event: "message", listener: (value: any) => void): this;
prependListener(event: "messageerror", listener: (error: Error) => void): this;
prependListener(event: "online", listener: () => void): this;
prependListener(event: 'error', listener: (err: Error) => void): this;
prependListener(event: 'exit', listener: (exitCode: number) => void): this;
prependListener(event: 'message', listener: (value: any) => void): this;
prependListener(event: 'messageerror', listener: (error: Error) => void): this;
prependListener(event: 'online', listener: () => void): this;
prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
prependOnceListener(event: "error", listener: (err: Error) => void): this;
prependOnceListener(event: "exit", listener: (exitCode: number) => void): this;
prependOnceListener(event: "message", listener: (value: any) => void): this;
prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
prependOnceListener(event: "online", listener: () => void): this;
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
prependOnceListener(event: 'exit', listener: (exitCode: number) => void): this;
prependOnceListener(event: 'message', listener: (value: any) => void): this;
prependOnceListener(event: 'messageerror', listener: (error: Error) => void): this;
prependOnceListener(event: 'online', listener: () => void): this;
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
removeListener(event: "error", listener: (err: Error) => void): this;
removeListener(event: "exit", listener: (exitCode: number) => void): this;
removeListener(event: "message", listener: (value: any) => void): this;
removeListener(event: "messageerror", listener: (error: Error) => void): this;
removeListener(event: "online", listener: () => void): this;
removeListener(event: 'error', listener: (err: Error) => void): this;
removeListener(event: 'exit', listener: (exitCode: number) => void): this;
removeListener(event: 'message', listener: (value: any) => void): this;
removeListener(event: 'messageerror', listener: (error: Error) => void): this;
removeListener(event: 'online', listener: () => void): this;
removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
off(event: "error", listener: (err: Error) => void): this;
off(event: "exit", listener: (exitCode: number) => void): this;
off(event: "message", listener: (value: any) => void): this;
off(event: "messageerror", listener: (error: Error) => void): this;
off(event: "online", listener: () => void): this;
off(event: 'error', listener: (err: Error) => void): this;
off(event: 'exit', listener: (exitCode: number) => void): this;
off(event: 'message', listener: (value: any) => void): this;
off(event: 'messageerror', listener: (error: Error) => void): this;
off(event: 'online', listener: () => void): this;
off(event: string | symbol, listener: (...args: any[]) => void): this;
}
interface BroadcastChannel extends NodeJS.RefCounted {}
/**
* Mark an object as not transferable.
* If `object` occurs in the transfer list of a `port.postMessage()` call, it will be ignored.
* Instances of `BroadcastChannel` allow asynchronous one-to-many communication
* with all other `BroadcastChannel` instances bound to the same channel name.
*
* In particular, this makes sense for objects that can be cloned, rather than transferred,
* and which are used by other objects on the sending side. For example, Node.js marks
* the `ArrayBuffer`s it uses for its Buffer pool with this.
* ```js
* 'use strict';
*
* const {
* isMainThread,
* BroadcastChannel,
* Worker
* } = require('worker_threads');
*
* const bc = new BroadcastChannel('hello');
*
* if (isMainThread) {
* let c = 0;
* bc.onmessage = (event) => {
* console.log(event.data);
* if (++c === 10) bc.close();
* };
* for (let n = 0; n < 10; n++)
* new Worker(__filename);
* } else {
* bc.postMessage('hello from every worker');
* bc.close();
* }
* ```
* @since v15.4.0
* @experimental
*/
class BroadcastChannel {
readonly name: string;
/**
* Invoked with a single \`MessageEvent\` argument when a message is received.
* @since v15.4.0
*/
onmessage: (message: unknown) => void;
/**
* Invoked with a received message cannot be deserialized.
* @since v15.4.0
*/
onmessageerror: (message: unknown) => void;
constructor(name: string);
/**
* Closes the `BroadcastChannel` connection.
* @since v15.4.0
*/
close(): void;
/**
* @since v15.4.0
* @param message Any cloneable JavaScript value.
*/
postMessage(message: unknown): void;
}
/**
* Mark an object as not transferable. If `object` occurs in the transfer list of
* a `port.postMessage()` call, it is ignored.
*
* In particular, this makes sense for objects that can be cloned, rather than
* transferred, and which are used by other objects on the sending side.
* For example, Node.js marks the `ArrayBuffer`s it uses for its `Buffer pool` with this.
*
* This operation cannot be undone.
*
* ```js
* const { MessageChannel, markAsUntransferable } = require('worker_threads');
*
* const pooledBuffer = new ArrayBuffer(8);
* const typedArray1 = new Uint8Array(pooledBuffer);
* const typedArray2 = new Float64Array(pooledBuffer);
*
* markAsUntransferable(pooledBuffer);
*
* const { port1 } = new MessageChannel();
* port1.postMessage(typedArray1, [ typedArray1.buffer ]);
*
* // The following line prints the contents of typedArray1 -- it still owns
* // its memory and has been cloned, not transferred. Without
* // `markAsUntransferable()`, this would print an empty Uint8Array.
* // typedArray2 is intact as well.
* console.log(typedArray1);
* console.log(typedArray2);
* ```
*
* There is no equivalent to this API in browsers.
* @since v14.5.0, v12.19.0
*/
function markAsUntransferable(object: object): void;
/**
* Transfer a `MessagePort` to a different `vm` Context. The original `port`
* object will be rendered unusable, and the returned `MessagePort` instance will
* take its place.
* Transfer a `MessagePort` to a different `vm` Context. The original `port`object is rendered unusable, and the returned `MessagePort` instance
* takes its place.
*
* The returned `MessagePort` will be an object in the target context, and will
* inherit from its global `Object` class. Objects passed to the
* `port.onmessage()` listener will also be created in the target context
* The returned `MessagePort` is an object in the target context and
* inherits from its global `Object` class. Objects passed to the [`port.onmessage()`](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage) listener are also created in the
* target context
* and inherit from its global `Object` class.
*
* However, the created `MessagePort` will no longer inherit from
* `EventEmitter`, and only `port.onmessage()` can be used to receive
* However, the created `MessagePort` no longer inherits from [`EventTarget`](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget), and only
* [`port.onmessage()`](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage) can be used to receive
* events using it.
* @since v11.13.0
* @param port The message port to transfer.
* @param contextifiedSandbox A `contextified` object as returned by the `vm.createContext()` method.
*/
function moveMessagePortToContext(port: MessagePort, context: Context): MessagePort;
function moveMessagePortToContext(port: MessagePort, contextifiedSandbox: Context): MessagePort;
/**
* Receive a single message from a given `MessagePort`. If no message is available,
* `undefined` is returned, otherwise an object with a single `message` property
* that contains the message payload, corresponding to the oldest message in the
* `MessagePort`’s queue.
* Receive a single message from a given `MessagePort`. If no message is available,`undefined` is returned, otherwise an object with a single `message` property
* that contains the message payload, corresponding to the oldest message in the`MessagePort`’s queue.
*
* ```js
* const { MessageChannel, receiveMessageOnPort } = require('worker_threads');
* const { port1, port2 } = new MessageChannel();
* port1.postMessage({ hello: 'world' });
*
* console.log(receiveMessageOnPort(port2));
* // Prints: { message: { hello: 'world' } }
* console.log(receiveMessageOnPort(port2));
* // Prints: undefined
* ```
*
* When this function is used, no `'message'` event is emitted and the`onmessage` listener is not invoked.
* @since v12.3.0
*/
function receiveMessageOnPort(port: MessagePort): { message: any } | undefined;
function receiveMessageOnPort(port: MessagePort):
| {
message: any;
}
| undefined;
type Serializable = string | object | number | boolean | bigint;
/**
* Within a worker thread, `worker.getEnvironmentData()` returns a clone
* of data passed to the spawning thread's `worker.setEnvironmentData()`.
* Every new `Worker` receives its own copy of the environment data
* automatically.
*
* ```js
* const {
* Worker,
* isMainThread,
* setEnvironmentData,
* getEnvironmentData,
* } = require('worker_threads');
*
* if (isMainThread) {
* setEnvironmentData('Hello', 'World!');
* const worker = new Worker(__filename);
* } else {
* console.log(getEnvironmentData('Hello')); // Prints 'World!'.
* }
* ```
* @since v15.12.0
* @experimental
* @param key Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.
*/
function getEnvironmentData(key: Serializable): Serializable;
/**
* The `worker.setEnvironmentData()` API sets the content of`worker.getEnvironmentData()` in the current thread and all new `Worker`instances spawned from the current context.
* @since v15.12.0
* @experimental
* @param key Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.
* @param value Any arbitrary, cloneable JavaScript value that will be cloned and passed automatically to all new `Worker` instances. If `value` is passed as `undefined`, any previously set value
* for the `key` will be deleted.
*/
function setEnvironmentData(key: Serializable, value: Serializable): void;
}
declare module 'node:worker_threads' {
export * from 'worker_threads';

279
packages/node_modules/@node-red/editor-client/src/types/node/zlib.d.ts vendored
View File

@ -1,9 +1,100 @@
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
/**
* The `zlib` module provides compression functionality implemented using Gzip,
* Deflate/Inflate, and Brotli.
*
* To access it:
*
* ```js
* const zlib = require('zlib');
* ```
*
* Compression and decompression are built around the Node.js `Streams API`.
*
* Compressing or decompressing a stream (such as a file) can be accomplished by
* piping the source stream through a `zlib` `Transform` stream into a destination
* stream:
*
* ```js
* const { createGzip } = require('zlib');
* const { pipeline } = require('stream');
* const {
* createReadStream,
* createWriteStream
* } = require('fs');
*
* const gzip = createGzip();
* const source = createReadStream('input.txt');
* const destination = createWriteStream('input.txt.gz');
*
* pipeline(source, gzip, destination, (err) => {
* if (err) {
* console.error('An error occurred:', err);
* process.exitCode = 1;
* }
* });
*
* // Or, Promisified
*
* const { promisify } = require('util');
* const pipe = promisify(pipeline);
*
* async function do_gzip(input, output) {
* const gzip = createGzip();
* const source = createReadStream(input);
* const destination = createWriteStream(output);
* await pipe(source, gzip, destination);
* }
*
* do_gzip('input.txt', 'input.txt.gz')
* .catch((err) => {
* console.error('An error occurred:', err);
* process.exitCode = 1;
* });
* ```
*
* It is also possible to compress or decompress data in a single step:
*
* ```js
* const { deflate, unzip } = require('zlib');
*
* const input = '.................................';
* deflate(input, (err, buffer) => {
* if (err) {
* console.error('An error occurred:', err);
* process.exitCode = 1;
* }
* console.log(buffer.toString('base64'));
* });
*
* const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');
* unzip(buffer, (err, buffer) => {
* if (err) {
* console.error('An error occurred:', err);
* process.exitCode = 1;
* }
* console.log(buffer.toString());
* });
*
* // Or, Promisified
*
* const { promisify } = require('util');
* const do_unzip = promisify(unzip);
*
* do_unzip(buffer)
* .then((buf) => console.log(buf.toString()))
* .catch((err) => {
* console.error('An error occurred:', err);
* process.exitCode = 1;
* });
* ```
* @since v0.5.8
* @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/zlib.js)
*/
declare module 'zlib' {
import * as stream from 'stream';
import * as stream from 'node:stream';
interface ZlibOptions {
/**
* @default constants.Z_NO_FLUSH
@ -25,7 +116,6 @@ declare module 'zlib' {
info?: boolean | undefined;
maxOutputLength?: number | undefined;
}
interface BrotliOptions {
/**
* @default constants.BROTLI_OPERATION_PROCESS
@ -39,15 +129,16 @@ declare module 'zlib' {
* @default 16*1024
*/
chunkSize?: number | undefined;
params?: {
/**
* Each key is a `constants.BROTLI_*` constant.
*/
[key: number]: boolean | number;
} | undefined;
params?:
| {
/**
* Each key is a `constants.BROTLI_*` constant.
*/
[key: number]: boolean | number;
}
| undefined;
maxOutputLength?: number | undefined;
}
interface Zlib {
/** @deprecated Use bytesWritten instead. */
readonly bytesRead: number;
@ -57,111 +148,192 @@ declare module 'zlib' {
flush(kind?: number, callback?: () => void): void;
flush(callback?: () => void): void;
}
interface ZlibParams {
params(level: number, strategy: number, callback: () => void): void;
}
interface ZlibReset {
reset(): void;
}
interface BrotliCompress extends stream.Transform, Zlib { }
interface BrotliDecompress extends stream.Transform, Zlib { }
interface Gzip extends stream.Transform, Zlib { }
interface Gunzip extends stream.Transform, Zlib { }
interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams { }
interface Inflate extends stream.Transform, Zlib, ZlibReset { }
interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams { }
interface InflateRaw extends stream.Transform, Zlib, ZlibReset { }
interface Unzip extends stream.Transform, Zlib { }
interface BrotliCompress extends stream.Transform, Zlib {}
interface BrotliDecompress extends stream.Transform, Zlib {}
interface Gzip extends stream.Transform, Zlib {}
interface Gunzip extends stream.Transform, Zlib {}
interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
interface Inflate extends stream.Transform, Zlib, ZlibReset {}
interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
interface InflateRaw extends stream.Transform, Zlib, ZlibReset {}
interface Unzip extends stream.Transform, Zlib {}
/**
* Creates and returns a new `BrotliCompress` object.
* @since v11.7.0, v10.16.0
*/
function createBrotliCompress(options?: BrotliOptions): BrotliCompress;
/**
* Creates and returns a new `BrotliDecompress` object.
* @since v11.7.0, v10.16.0
*/
function createBrotliDecompress(options?: BrotliOptions): BrotliDecompress;
/**
* Creates and returns a new `Gzip` object.
* See `example`.
* @since v0.5.8
*/
function createGzip(options?: ZlibOptions): Gzip;
/**
* Creates and returns a new `Gunzip` object.
* @since v0.5.8
*/
function createGunzip(options?: ZlibOptions): Gunzip;
/**
* Creates and returns a new `Deflate` object.
* @since v0.5.8
*/
function createDeflate(options?: ZlibOptions): Deflate;
/**
* Creates and returns a new `Inflate` object.
* @since v0.5.8
*/
function createInflate(options?: ZlibOptions): Inflate;
/**
* Creates and returns a new `DeflateRaw` object.
*
* An upgrade of zlib from 1.2.8 to 1.2.11 changed behavior when `windowBits`is set to 8 for raw deflate streams. zlib would automatically set `windowBits`to 9 if was initially set to 8\. Newer
* versions of zlib will throw an exception,
* so Node.js restored the original behavior of upgrading a value of 8 to 9,
* since passing `windowBits = 9` to zlib actually results in a compressed stream
* that effectively uses an 8-bit window only.
* @since v0.5.8
*/
function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
/**
* Creates and returns a new `InflateRaw` object.
* @since v0.5.8
*/
function createInflateRaw(options?: ZlibOptions): InflateRaw;
/**
* Creates and returns a new `Unzip` object.
* @since v0.5.8
*/
function createUnzip(options?: ZlibOptions): Unzip;
type InputType = string | ArrayBuffer | NodeJS.ArrayBufferView;
type CompressCallback = (error: Error | null, result: Buffer) => void;
/**
* @since v11.7.0, v10.16.0
*/
function brotliCompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
function brotliCompress(buf: InputType, callback: CompressCallback): void;
namespace brotliCompress {
function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
}
/**
* Compress a chunk of data with `BrotliCompress`.
* @since v11.7.0, v10.16.0
*/
function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer;
/**
* @since v11.7.0, v10.16.0
*/
function brotliDecompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
function brotliDecompress(buf: InputType, callback: CompressCallback): void;
namespace brotliDecompress {
function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
}
/**
* Decompress a chunk of data with `BrotliDecompress`.
* @since v11.7.0, v10.16.0
*/
function brotliDecompressSync(buf: InputType, options?: BrotliOptions): Buffer;
/**
* @since v0.6.0
*/
function deflate(buf: InputType, callback: CompressCallback): void;
function deflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
namespace deflate {
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
}
/**
* Compress a chunk of data with `Deflate`.
* @since v0.11.12
*/
function deflateSync(buf: InputType, options?: ZlibOptions): Buffer;
/**
* @since v0.6.0
*/
function deflateRaw(buf: InputType, callback: CompressCallback): void;
function deflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
namespace deflateRaw {
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
}
/**
* Compress a chunk of data with `DeflateRaw`.
* @since v0.11.12
*/
function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
/**
* @since v0.6.0
*/
function gzip(buf: InputType, callback: CompressCallback): void;
function gzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
namespace gzip {
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
}
/**
* Compress a chunk of data with `Gzip`.
* @since v0.11.12
*/
function gzipSync(buf: InputType, options?: ZlibOptions): Buffer;
/**
* @since v0.6.0
*/
function gunzip(buf: InputType, callback: CompressCallback): void;
function gunzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
namespace gunzip {
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
}
/**
* Decompress a chunk of data with `Gunzip`.
* @since v0.11.12
*/
function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer;
/**
* @since v0.6.0
*/
function inflate(buf: InputType, callback: CompressCallback): void;
function inflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
namespace inflate {
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
}
/**
* Decompress a chunk of data with `Inflate`.
* @since v0.11.12
*/
function inflateSync(buf: InputType, options?: ZlibOptions): Buffer;
/**
* @since v0.6.0
*/
function inflateRaw(buf: InputType, callback: CompressCallback): void;
function inflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
namespace inflateRaw {
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
}
/**
* Decompress a chunk of data with `InflateRaw`.
* @since v0.11.12
*/
function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
/**
* @since v0.6.0
*/
function unzip(buf: InputType, callback: CompressCallback): void;
function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
namespace unzip {
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
}
/**
* Decompress a chunk of data with `Unzip`.
* @since v0.11.12
*/
function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
namespace constants {
const BROTLI_DECODE: number;
const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;
@ -199,7 +371,6 @@ declare module 'zlib' {
const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: number;
const BROTLI_DECODER_RESULT_SUCCESS: number;
const BROTLI_DECODER_SUCCESS: number;
const BROTLI_DEFAULT_MODE: number;
const BROTLI_DEFAULT_QUALITY: number;
const BROTLI_DEFAULT_WINDOW: number;
@ -211,16 +382,13 @@ declare module 'zlib' {
const BROTLI_MIN_INPUT_BLOCK_BITS: number;
const BROTLI_MIN_QUALITY: number;
const BROTLI_MIN_WINDOW_BITS: number;
const BROTLI_MODE_FONT: number;
const BROTLI_MODE_GENERIC: number;
const BROTLI_MODE_TEXT: number;
const BROTLI_OPERATION_EMIT_METADATA: number;
const BROTLI_OPERATION_FINISH: number;
const BROTLI_OPERATION_FLUSH: number;
const BROTLI_OPERATION_PROCESS: number;
const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: number;
const BROTLI_PARAM_LARGE_WINDOW: number;
const BROTLI_PARAM_LGBLOCK: number;
@ -230,7 +398,6 @@ declare module 'zlib' {
const BROTLI_PARAM_NPOSTFIX: number;
const BROTLI_PARAM_QUALITY: number;
const BROTLI_PARAM_SIZE_HINT: number;
const DEFLATE: number;
const DEFLATERAW: number;
const GUNZIP: number;
@ -238,7 +405,6 @@ declare module 'zlib' {
const INFLATE: number;
const INFLATERAW: number;
const UNZIP: number;
// Allowed flush values.
const Z_NO_FLUSH: number;
const Z_PARTIAL_FLUSH: number;
@ -247,7 +413,6 @@ declare module 'zlib' {
const Z_FINISH: number;
const Z_BLOCK: number;
const Z_TREES: number;
// Return codes for the compression/decompression functions.
// Negative values are errors, positive values are used for special but normal events.
const Z_OK: number;
@ -259,39 +424,31 @@ declare module 'zlib' {
const Z_MEM_ERROR: number;
const Z_BUF_ERROR: number;
const Z_VERSION_ERROR: number;
// Compression levels.
const Z_NO_COMPRESSION: number;
const Z_BEST_SPEED: number;
const Z_BEST_COMPRESSION: number;
const Z_DEFAULT_COMPRESSION: number;
// Compression strategy.
const Z_FILTERED: number;
const Z_HUFFMAN_ONLY: number;
const Z_RLE: number;
const Z_FIXED: number;
const Z_DEFAULT_STRATEGY: number;
const Z_DEFAULT_WINDOWBITS: number;
const Z_MIN_WINDOWBITS: number;
const Z_MAX_WINDOWBITS: number;
const Z_MIN_CHUNK: number;
const Z_MAX_CHUNK: number;
const Z_DEFAULT_CHUNK: number;
const Z_MIN_MEMLEVEL: number;
const Z_MAX_MEMLEVEL: number;
const Z_DEFAULT_MEMLEVEL: number;
const Z_MIN_LEVEL: number;
const Z_MAX_LEVEL: number;
const Z_DEFAULT_LEVEL: number;
const ZLIB_VERNUM: number;
}
// Allowed flush values.
/** @deprecated Use `constants.Z_NO_FLUSH` */
const Z_NO_FLUSH: number;
@ -307,7 +464,6 @@ declare module 'zlib' {
const Z_BLOCK: number;
/** @deprecated Use `constants.Z_TREES` */
const Z_TREES: number;
// Return codes for the compression/decompression functions.
// Negative values are errors, positive values are used for special but normal events.
/** @deprecated Use `constants.Z_OK` */
@ -328,7 +484,6 @@ declare module 'zlib' {
const Z_BUF_ERROR: number;
/** @deprecated Use `constants.Z_VERSION_ERROR` */
const Z_VERSION_ERROR: number;
// Compression levels.
/** @deprecated Use `constants.Z_NO_COMPRESSION` */
const Z_NO_COMPRESSION: number;
@ -338,7 +493,6 @@ declare module 'zlib' {
const Z_BEST_COMPRESSION: number;
/** @deprecated Use `constants.Z_DEFAULT_COMPRESSION` */
const Z_DEFAULT_COMPRESSION: number;
// Compression strategy.
/** @deprecated Use `constants.Z_FILTERED` */
const Z_FILTERED: number;
@ -350,7 +504,6 @@ declare module 'zlib' {
const Z_FIXED: number;
/** @deprecated Use `constants.Z_DEFAULT_STRATEGY` */
const Z_DEFAULT_STRATEGY: number;
/** @deprecated */
const Z_BINARY: number;
/** @deprecated */

BIN
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/ade705761eb7e702770d.ttf → packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/7064e66c3890a12c47b4.ttf vendored
View File

Binary file not shown.

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/css.worker.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/css.worker.js.LICENSE.txt vendored
View File

@ -1,6 +1,6 @@
/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
* Version: 0.36.1(6c56744c3419458f0dd48864520b759d1a3a1ca8)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/editor.js vendored
View File

File diff suppressed because one or more lines are too long

6
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/editor.js.LICENSE.txt vendored
View File

@ -2,7 +2,11 @@
/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
* Version: 0.36.1(6c56744c3419458f0dd48864520b759d1a3a1ca8)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/
/*!---------------------------------------------------------------------------------------------
* Copyright (C) David Owens II, owensd.io. All rights reserved.
*--------------------------------------------------------------------------------------------*/

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/editor.worker.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/html.worker.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/html.worker.js.LICENSE.txt vendored
View File

@ -1,6 +1,6 @@
/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
* Version: 0.36.1(6c56744c3419458f0dd48864520b759d1a3a1ca8)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/json.worker.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/json.worker.js.LICENSE.txt vendored
View File

@ -1,6 +1,6 @@
/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
* Version: 0.36.1(6c56744c3419458f0dd48864520b759d1a3a1ca8)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/

390
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/cs.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Další akce..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Zavřít dialogové okno",
"dialogErrorMessage": "Chyba",
"dialogInfoMessage": "Informace",
"dialogPendingMessage": "Probíhá zpracování.",
"dialogWarningMessage": "Upozornění",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Další akce..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "vstup"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Rozlišovat malá a velká písmena",
"regexDescription": "Použit regulární výraz",
"wordsDescription": "Pouze celá slova"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "vstup",
"label.preserveCaseToggle": "Zachovávat velikost písmen"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Nesvázáno s klávesovou zkratkou"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Pole výběru"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Další akce..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Vymazat",
"disable filter on type": "Zakázat filtrování při psaní",
"empty": "Nebyly nalezeny žádné elementy.",
"enable filter on type": "Povolit filtrování při psaní",
"found": "Shoda s {0} z {1} elementů"
"close": "Zavřít",
"filter": "Filtrovat",
"fuzzySearch": "Přibližná shoda",
"not found": "Nenašly se žádné prvky.",
"type to filter": "Pro filtrování zadejte text.",
"type to search": "Zadejte hledaný text"
},
"vs/base/common/actions": {
"submenu.empty": "(prázdné)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Vlastní",
"inputModeEntry": "Stisknutím klávesy Enter potvrdíte vstup. Klávesou Esc akci zrušíte.",
"inputModeEntryDescription": "{0} (Potvrdíte stisknutím klávesy Enter. Zrušíte klávesou Esc.)",
"ok": "OK",
"quickInput.back": "Zpět",
"quickInput.backWithKeybinding": "Zpět ({0})",
"quickInput.countSelected": "Vybrané: {0}",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "Počet výsledků: {0}",
"quickInputBox.ariaLabel": "Pokud chcete zúžit počet výsledků, začněte psát."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Rychlý vstup"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "Editor není v tuto chvíli dostupný. Možnosti zobrazíte stisknutím klávesy {0}.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Zpět"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "Počet kurzorů je omezen na {0}."
"cursors.maximum": "Počet kurzorů byl omezen na {0}. Zvažte použití funkce [find and replace](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) pro větší změny nebo zvýšení nastavení limitu více kurzorů editoru.",
"goToSetting": "Zvýšit limit více kurzorů"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " k navigaci ve změnách použijte Shift+F7.",
"diff.tooLarge": "Nelze porovnat soubory, protože jeden soubor je příliš velký.",
"diffInsertIcon": "Dekorace řádku pro operace vložení do editoru rozdílů",
"diffRemoveIcon": "Dekorace řádku pro operace odebrání do editoru rozdílů"
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Určuje, jestli editor zobrazí CodeLens.",
"detectIndentation": "Určuje, jestli se má při otevření souboru na základě obsahu souboru automaticky detekovat nastavení #editor.tabSize# a #editor.insertSpaces#.",
"detectIndentation": "Určuje, jestli se {0} a {1} automaticky zjistí při otevření souboru na základě obsahu souboru.",
"diffAlgorithm.experimental": "Používá experimentální rozdílový algoritmus.",
"diffAlgorithm.smart": "Používá výchozí rozdílový algoritmus.",
"editor.experimental.asyncTokenization": "Určuje, jestli se má tokenizace provádět asynchronně ve webovém pracovním procesu.",
"editorConfigurationTitle": "Editor",
"ignoreTrimWhitespace": "Když je povoleno, editor rozdílů ignoruje změny v počátečních nebo koncových prázdných znacích.",
"insertSpaces": "Umožňuje vkládat mezery při stisknutí klávesy Tab. Toto nastavení je přepsáno na základě obsahu souboru, pokud je zapnuto nastavení #editor.detectIndentation#.",
"indentSize": "Počet mezer použitých pro odsazení nebo „tabSize“ pro použití hodnoty z #editor.tabSize#. Toto nastavení se přepíše na základě obsahu souboru, když je zapnutá možnost #editor.detectIndentation#.",
"insertSpaces": "Umožňuje vkládat mezery při stisknutí klávesy Tab. Toto nastavení je přepsáno na základě obsahu souboru, pokud je zapnuto {0}.",
"largeFileOptimizations": "Speciální zpracování velkých souborů za účelem zakázání určitých funkcí náročných na paměť",
"maxComputationTime": "Časový limit v milisekundách, po kterém je zrušen výpočet rozdílů. Pokud nechcete nastavit žádný časový limit, zadejte hodnotu 0.",
"maxFileSize": "Maximální velikost souboru v MB, pro který se mají vypočítat rozdíly. Pro zrušení omezení použijte 0.",
"maxTokenizationLineLength": "Řádky s větší délkou se nebudou z důvodu výkonu tokenizovat.",
"renderIndicators": "Určuje, jestli má editor rozdílů zobrazovat indikátory +/- pro přidané/odebrané změny.",
"renderMarginRevertIcon": "Pokud je tato možnost povolená, zobrazuje editor rozdílů na okraji piktogramu šipky pro vrácení změn.",
"schema.brackets": "Definuje symboly hranatých závorek, které zvyšují nebo snižují úroveň odsazení.",
"schema.closeBracket": "Znak pravé hranaté závorky nebo řetězcová sekvence",
"schema.colorizedBracketPairs": "Definuje dvojice závorek, které jsou zabarvené podle jejich úrovně vnoření, pokud je zabarvení dvojice závorek povoleno.",
@ -140,14 +161,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.true": "Sémantické zvýrazňování je u všech barevných motivů povolené.",
"sideBySide": "Určuje, jestli má editor rozdílů zobrazovat rozdíly vedle sebe nebo vloženě (inline).",
"stablePeek": "Udržuje editory náhledu otevřené i po poklikání na jejich obsah nebo stisknutí klávesy Esc.",
"tabSize": "Počet mezer, které odpovídají tabulátoru. Pokud je zapnuto nastavení #editor.detectIndentation#, je toto nastavení přepsáno na základě obsahu souboru.",
"tabSize": "Počet mezer, které odpovídají tabulátoru. Toto nastavení se přepíše na základě obsahu souboru, když je zapnuto {0}.",
"trimAutoWhitespace": "Odebrat automaticky vložené koncové prázdné znaky",
"wordBasedSuggestions": "Určuje, jestli se dokončení mají počítat na základě slov v dokumentu.",
"wordBasedSuggestionsMode": "Určuje, ze kterých dokumentů se počítá doplňování na základě slov.",
"wordBasedSuggestionsMode.allDocuments": "Navrhovaná slova ze všech otevřených dokumentů",
"wordBasedSuggestionsMode.currentDocument": "Navrhovat jen slova z aktivního dokumentu",
"wordBasedSuggestionsMode.matchingDocuments": "Navrhovat slova ze všech otevřených dokumentů stejného jazyka",
"wordWrap.inherit": "Řádky se zalomí podle nastavení #editor.wordWrap#.",
"wordWrap.inherit": "Řádky se zalomí podle nastavení {0}.",
"wordWrap.off": "Řádky se nebudou nikdy zalamovat.",
"wordWrap.on": "Řádky se budou zalamovat podle šířky viewportu (zobrazení)."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Určuje, jestli se mají návrhy přijímat po stisknutí klávesy Enter (navíc ke klávese Tab). Pomáhá vyhnout se nejednoznačnosti mezi vkládáním nových řádků nebo přijímáním návrhů.",
"acceptSuggestionOnEnterSmart": "Přijmout návrh pomocí klávesy Enter, pouze pokud jde o návrh změny v textu",
"accessibilityPageSize": "Určuje počet řádků v editoru, které může čtečka obrazovky přečíst najednou. Když rozpoznáme čtečku obrazovky, automaticky nastavíme výchozí hodnotu na 500. Upozornění: Hodnoty větší než výchozí hodnota mají vliv na výkon.",
"accessibilitySupport": "Určuje, jestli by měl editor běžet v režimu optimalizovaném pro čtečky obrazovky. Při zapnutí této možnosti se zakáže zalamování řádků.",
"accessibilitySupport.auto": "Editor bude pomocí rozhraní API platformy zjišťovat, jestli je připojená čtečka obrazovky.",
"accessibilitySupport.off": "Editor nebude nikdy optimalizován pro použití se čtečkou obrazovky.",
"accessibilitySupport.on": "Editor bude trvale optimalizován pro použití se čtečkou obrazovky. Zakáže se zalamování řádků.",
"accessibilitySupport": "Určuje, jestli se má uživatelské rozhraní spouštět v režimu, ve kterém je optimalizované pro čtečky obrazovky.",
"accessibilitySupport.auto": "Použít rozhraní API platformy ke zjištění, jestli je připojená čtečka obrazovky",
"accessibilitySupport.off": "Předpokládat, že čtečka obrazovky není připojená",
"accessibilitySupport.on": "Optimalizace pro použití se čtečkou obrazovky",
"alternativeDeclarationCommand": "ID alternativního příkazu, který je prováděn, když výsledkem příkazu Přejít na deklaraci je aktuální umístění",
"alternativeDefinitionCommand": "ID alternativního příkazu, který je prováděn, když výsledkem příkazu Přejít k definici je aktuální umístění",
"alternativeImplementationCommand": "ID alternativního příkazu, který je prováděn, když výsledkem příkazu Přejít na implementaci je aktuální umístění",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Určuje, jestli by měl editor k levým uvozovkám automaticky doplňovat pravé uvozovky, když uživatel přidá levé uvozovky.",
"autoIndent": "Určuje, jestli by měl editor automaticky upravovat odsazení, když uživatel píše, vkládá, přesouvá nebo odsazuje řádky.",
"autoSurround": "Určuje, jestli má editor automaticky ohraničit výběry při psaní uvozovek nebo závorek.",
"bracketPairColorization.enabled": "Určuje, jestli je povolené zabarvení dvojice závorek, nebo ne. Pokud chcete přepsat barvy zvýraznění závorek, použijte #workbench.colorCustomizations#.",
"bracketPairColorization.enabled": "Určuje, jestli je povolené zabarvení dvojice závorek, nebo ne. Pokud chcete přepsat barvy zvýraznění závorek, použijte {0}.",
"bracketPairColorization.independentColorPoolPerBracketType": "Určuje, jestli má každý typ hranaté závorky svůj vlastní nezávislý fond barev.",
"codeActions": "Povolí v editoru ikonu žárovky s nabídkou akcí kódu.",
"codeLens": "Určuje, jestli editor zobrazí CodeLens.",
"codeLensFontFamily": "Určuje rodinu písem pro CodeLens.",
"codeLensFontSize": "Určuje velikost písma v pixelech pro CodeLens. Při nastavení na hodnotu 0 se použije 90 % hodnoty #editor.fontSize#.",
"colorDecorators": "Určuje, jestli se mají v editoru vykreslovat vložené (inline) dekoratéry barev a ovládací prvky pro výběr barev.",
"colorDecoratorsLimit": "Určuje maximální počet barevných dekorátorů, které lze vykreslit v editoru najednou.",
"columnSelection": "Povolit výběr sloupce pomocí myši a klávesnice",
"comments.ignoreEmptyLines": "Určuje, jestli mají být ignorovány prázdné řádky u akcí přepínání, přidávání nebo odebírání pro řádkové komentáře.",
"comments.insertSpace": "Určuje, jestli je při komentování vložen znak mezery.",
"copyWithSyntaxHighlighting": "Určuje, jestli má být zvýrazňování syntaxe zkopírováno do schránky.",
"cursorBlinking": "Určuje styl animace kurzoru.",
"cursorSmoothCaretAnimation": "Určuje, jestli má být povolena plynulá animace kurzoru.",
"cursorSmoothCaretAnimation.explicit": "Animace plynulé stříšky je povolená jenom v případě, že uživatel přesune kurzor explicitním gestem.",
"cursorSmoothCaretAnimation.off": "Animace plynulé stříšky je zakázaná.",
"cursorSmoothCaretAnimation.on": "Animace plynulé stříšky je vždy povolená.",
"cursorStyle": "Určuje styl kurzoru.",
"cursorSurroundingLines": "Určuje minimální počet viditelných řádků před a za kurzorem. V některých jiných editorech se toto nastavení označuje jako scrollOff nebo scrollOffset.",
"cursorSurroundingLines": "Určuje minimální počet viditelných řádků před (minimálně 0) a za kurzorem (minimálně 1). V některých jiných editorech se toto nastavení označuje jako scrollOff nebo scrollOffset.",
"cursorSurroundingLinesStyle": "Určuje, kdy se má vynucovat nastavení cursorSurroundingLines.",
"cursorSurroundingLinesStyle.all": "cursorSurroundingLines se vynucuje vždy.",
"cursorSurroundingLinesStyle.default": "cursorSurroundingLines se vynucuje pouze v případě, že se aktivuje pomocí klávesnice nebo rozhraní API.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Určuje, jestli se má pomocí gesta myší Přejít k definici vždy otevřít widget náhledu.",
"deprecated": "Toto nastavení je zastaralé. Místo něj prosím použijte samostatné nastavení, například editor.suggest.showKeywords nebo editor.suggest.showSnippets.",
"dragAndDrop": "Určuje, jestli má editor povolit přesouvání vybraných položek přetažením.",
"dropIntoEditor.enabled": "Určuje, jestli můžete soubor přetáhnout do textového editoru podržením klávesy Shift (místo otevření souboru v editoru).",
"editor.autoClosingBrackets.beforeWhitespace": "Automaticky k levým hranatým závorkám doplňovat pravé hranaté závorky, pouze pokud se kurzor nachází nalevo od prázdného znaku",
"editor.autoClosingBrackets.languageDefined": "Pomocí konfigurací jazyka můžete určit, kdy se mají k levým hranatým závorkám automaticky doplňovat pravé hranaté závorky.",
"editor.autoClosingDelete.auto": "Odebrat sousední koncové uvozovky nebo pravé hranaté závorky pouze v případě, že se vložily automaticky",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Povolí vodorovná vodítka jako vodítka pro párování se svislou závorkou.",
"editor.guides.highlightActiveBracketPair": "Řídí, zda má editor zvýraznit aktivní dvojici závorek.",
"editor.guides.highlightActiveIndentation": "Určuje, jestli má editor zvýraznit aktivní vodítko odsazení.",
"editor.guides.highlightActiveIndentation.always": "Zvýrazní aktivní vodítko odsazení i v případě, že jsou zvýrazněna vodítka hranatých závorek.",
"editor.guides.highlightActiveIndentation.false": "Nezvýrazňovat aktivní vodítko odsazení.",
"editor.guides.highlightActiveIndentation.true": "Zvýrazní aktivní vodítko odsazení.",
"editor.guides.indentation": "Určuje, jestli má editor vykreslovat vodítka odsazení.",
"editor.inlayHints.off": "Pomocné parametry pro vložené informace jsou zakázány.",
"editor.inlayHints.offUnlessPressed": "Vložené nápovědy jsou ve výchozím nastavení skryté a zobrazí se, když podržíte {0}.",
"editor.inlayHints.on": "Pomocné parametry pro vložené informace jsou povoleny.",
"editor.inlayHints.onUnlessPressed": "Vložené nápovědy se ve výchozím nastavení zobrazují a skryjí se, když podržíte {0}.",
"editor.stickyScroll": "Zobrazí vnořené aktuální obory během posouvání v horní části editoru.",
"editor.stickyScroll.": "Definuje maximální počet rychlých čar, které se mají zobrazit.",
"editor.suggest.matchOnWordStartOnly": "Pokud je povoleno filtrování IntelliSense, vyžaduje, aby se první znak shodoval na začátku slova. Například „c“ u „Console“ nebo „WebContext“, ale _ne_ na „description“. Pokud je funkce IntelliSense zakázaná, zobrazí se více výsledků, ale přesto je seřadí podle kvality shody.",
"editor.suggest.showClasss": "Pokud je povoleno, technologie IntelliSense zobrazí návrhy pro „class“.",
"editor.suggest.showColors": "Pokud je povoleno, technologie IntelliSense zobrazí návrhy pro „color“.",
"editor.suggest.showConstants": "Pokud je povoleno, technologie IntelliSense zobrazí návrhy pro „constant“.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Pokud je povoleno, technologie IntelliSense zobrazí návrhy pro „variable“.",
"editorViewAccessibleLabel": "Obsah editoru",
"emptySelectionClipboard": "Určuje, jestli se při kopírování bez výběru zkopíruje aktuální řádek.",
"experimentalWhitespaceRendering": "Určuje, jestli se prázdné znaky vykreslují pomocí nové experimentální metody.",
"experimentalWhitespaceRendering.font": "Použití nové metody vykreslování se znaky písma.",
"experimentalWhitespaceRendering.off": "Použití stabilní metody vykreslování.",
"experimentalWhitespaceRendering.svg": "Použití nové metody vykreslování s formáty svg.",
"fastScrollSensitivity": "Multiplikátor rychlosti posouvání při podržené klávese Alt",
"find.addExtraSpaceOnTop": "Určuje, jestli má widget Najít v editoru přidat další řádky na začátek. Pokud má hodnotu true, můžete v případě, že bude widget Najít viditelný, posunout zobrazení nad první řádek.",
"find.autoFindInSelection": "Určuje podmínku pro automatické zapnutí funkce Najít ve výběru.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Povolí nebo zakáže ligatury písem (funkce písma calt a liga). Změnou této hodnoty na řetězec je možné jemně odstupňovat řízení vlastnosti CSS font-feature-settings.",
"fontLigaturesGeneral": "Umožňuje nakonfigurovat ligatury písem nebo funkce písem. Může zde být buď logická hodnota, aby bylo možné povolit nebo zakázat ligatury, nebo řetězec pro hodnotu vlastnosti CSS font-feature-settings.",
"fontSize": "Určuje velikost písma v pixelech.",
"fontVariationSettings": "Explicitní vlastnost šablony stylů CSS font-variation-settings. Logickou hodnotu je možné předat, pokud je potřeba přeložit pouze tloušťku písma na nastavení varianty písma.",
"fontVariations": "Povolí nebo zakáže překlad z font-weight na font-variation-settings. Pokud chcete jemně detailní kontrolu vlastnosti šablony stylů CSS font-variation-settings, změňte ji na řetězec.",
"fontVariationsGeneral": "Nakonfiguruje varianty písma. Může to být logická hodnota, která povolí nebo zakáže překlad z font-weight na font-variation-settings, nebo řetězec pro hodnotu vlastnosti šablony stylů CSS font-variation-settings.",
"fontWeight": "Určuje tloušťku písma. Lze použít klíčová slova normal a bold nebo čísla v rozmezí od 1 do 1 000.",
"fontWeightErrorMessage": "Jsou povolena pouze klíčová slova normal a bold nebo čísla v rozmezí od 1 do 1 000.",
"formatOnPaste": "Určuje, jestli má editor automaticky formátovat vložený obsah. Musí být k dispozici formátovací modul, který by měl být schopen naformátovat rozsah v dokumentu.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Určuje, jestli se má zobrazit popisek po umístění ukazatele myši na prvek.",
"hover.sticky": "Určuje, jestli má popisek zobrazený při umístění ukazatele myši na prvek zůstat viditelný.",
"inlayHints.enable": "Povolí vložené tipy v editoru.",
"inlayHints.fontFamily": "Určuje rodinu písem vložených tipů v editoru. Když se nastaví na hodnotu „prázdná“, použije se #editor.fontFamily#.",
"inlayHints.fontSize": "Určuje velikost písma pomocných parametrů typu inlay v editoru. Výchozí hodnota 90% #editor.fontSize# se používá, pokud je nakonfigurovaná hodnota menší než 5 nebo větší než velikost písma editoru.",
"inlayHints.fontFamily": "Určuje rodinu písem vložených tipů v editoru. Když se nastaví na hodnotu „prázdná“, použije se {0}.",
"inlayHints.fontSize": "Určuje velikost písma vložené nápovědy v editoru. Ve výchozím nastavení se použije {0}, pokud je nakonfigurovaná hodnota menší než {1} nebo větší než velikost písma editoru.",
"inlayHints.padding": "Povolí odsazení kolem vložených nápověd v editoru.",
"inline": "Rychlé návrhy se zobrazují jako zástupný text.",
"inlineSuggest.enabled": "Určuje, jestli se mají v editoru automaticky zobrazovat vložené návrhy.",
"inlineSuggest.showToolbar": "Určuje, kdy se má zobrazit panel nástrojů vložených návrhů.",
"inlineSuggest.showToolbar.always": "Pokaždé, když se zobrazí vložený návrh, zobrazí se panel nástrojů vložených návrhů.",
"inlineSuggest.showToolbar.onHover": "Při najetí myší na vložený návrh se zobrazí panel nástrojů vložených návrhů.",
"letterSpacing": "Určuje mezery mezi písmeny v pixelech.",
"lineHeight": "Určuje výšku řádku. \r\n – Při použití hodnoty 0 se automaticky vypočítá výška řádku z velikosti písma.\r\n – Hodnoty mezi 0 a 8 se použijí jako multiplikátor s velikostí písma.\r\n – Hodnoty větší nebo rovny 8 se použijí jako efektivní hodnoty.",
"lineNumbers": "Řídí zobrazování čísel řádků.",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "Určuje, jestli jsou v editoru povolené propojené úpravy. V závislosti na jazyce se při úpravách aktualizují související symboly, například značky HTML.",
"links": "Určuje, jestli má editor rozpoznávat odkazy a nastavit je jako kliknutelné.",
"matchBrackets": "Zvýraznit odpovídající hranaté závorky",
"minimap.autohide": "Určuje, jestli se minimapa automaticky skryje.",
"minimap.enabled": "Určuje, jestli se má zobrazovat minimapa.",
"minimap.maxColumn": "Omezuje šířku minimapy tak, aby byl maximálně vykreslen jen určitý počet sloupců.",
"minimap.renderCharacters": "Vykreslí na řádku skutečné znaky (nikoli barevné čtverečky).",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "Minimapa má stejnou velikost jako obsah editoru (a může se posouvat).",
"mouseWheelScrollSensitivity": "Multiplikátor, který se má použít pro hodnoty deltaX a deltaY událostí posouvání kolečka myši",
"mouseWheelZoom": "Přiblížit písmo editoru při podržení klávesy Ctrl a současném použití kolečka myši",
"multiCursorLimit": "Určuje maximální počet kurzorů, které mohou být v aktivním editoru najednou.",
"multiCursorMergeOverlapping": "Sloučit několik kurzorů, pokud se překrývají",
"multiCursorModifier": "Modifikátor, který se má používat pro přidávání více kurzorů pomocí myši. Gesta myší Přejít k definici a Otevřít odkaz se přizpůsobí tak, aby s modifikátorem více kurzorů nebyla v konfliktu. [Další informace](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier)",
"multiCursorModifier": "Modifikátor, který se má používat pro přidávání více kurzorů pomocí myši. Gesta myší Přejít k definici a Otevřít odkaz se přizpůsobí tak, aby nebyla v konfliktu s [multicursor modifier](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier.alt": "Mapuje se na klávesu Alt ve Windows a Linuxu a na klávesu Option v macOS.",
"multiCursorModifier.ctrlCmd": "Mapuje se na klávesu Control ve Windows a Linuxu a na klávesu Command v macOS.",
"multiCursorPaste": "Řídí vkládání, když počet řádků vloženého textu odpovídá počtu kurzorů.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Určuje, jestli má být ve widgetu náhledu fokus na vloženém (inline) editoru nebo stromu.",
"peekWidgetDefaultFocus.editor": "Při otevření náhledu přepnout fokus na editor",
"peekWidgetDefaultFocus.tree": "Při otevření náhledu přepnout fokus na strom",
"quickSuggestions": "Určuje, jestli se mají při psaní automaticky zobrazovat návrhy.",
"quickSuggestions": "Ovládá, zda se mají při psaní automaticky zobrazovat návrhy. To je možné ovládat při psaní komentářů, řetězců a dalšího kódu. Rychlé návrhy se dají nakonfigurovat tak, aby se zobrazovaly jako stínový text nebo s widgetem návrhu. Pozor také na nastavení {0}, které řídí, zda budou návrhy vyvolány speciálními znaky.",
"quickSuggestions.comments": "Povoluje rychlé návrhy uvnitř komentářů.",
"quickSuggestions.other": "Povoluje rychlé návrhy mimo řetězce a komentáře.",
"quickSuggestions.strings": "Povoluje rychlé návrhy uvnitř řetězců.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Určuje, kdy se v mezeře u okraje zobrazí ovládací prvky sbalení.",
"showFoldingControls.always": "Vždy zobrazovat ovládací prvky sbalení",
"showFoldingControls.mouseover": "Zobrazit ovládací prvky sbalení, pouze pokud je ukazatel myši umístěn na mezeře u okraje",
"showFoldingControls.never": "Nikdy nezobrazujte ovládací prvky pro sbalování a zmenšujte velikost mezery.",
"showUnused": "Řídí zobrazování nepoužívaného kódu vyšedle.",
"smoothScrolling": "Určuje, jestli se má pro posouvání v editoru používat animace.",
"snippetSuggestions": "Určuje, jestli se mají fragmenty kódu zobrazovat společně s jinými návrhy a jak se mají seřazovat.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Emulovat chování výběru znaků tabulátoru, když se k odsazení používají mezery. Výběr se zastaví na tabulátorech.",
"suggest.filterGraceful": "Určuje, jestli jsou v návrzích filtrování a řazení povoleny drobné překlepy.",
"suggest.insertMode": "Určuje, jestli se mají při přijímání návrhů dokončování přepisovat slova. Poznámka: Závisí to na rozšířeních využívajících tuto funkci.",
"suggest.insertMode.always": "Při automatické aktivaci IntelliSense vždy vybírejte návrh.",
"suggest.insertMode.insert": "Vložit návrh bez přepsání textu napravo od kurzoru",
"suggest.insertMode.never": "Při automatické aktivaci IntelliSense nikdy nevybírejte návrh.",
"suggest.insertMode.replace": "Vložit návrh a přepsat text napravo od kurzoru",
"suggest.insertMode.whenQuickSuggestion": "Vyberte návrh jenom při aktivaci IntelliSense při psaní.",
"suggest.insertMode.whenTriggerCharacter": "Vyberte návrh jenom při aktivaci IntelliSense pomocí aktivačního znaku.",
"suggest.localityBonus": "Určuje, jestli se mají při řazení upřednostňovat slova, která jsou blízko kurzoru.",
"suggest.maxVisibleSuggestions.dep": "Toto nastavení je zastaralé. Velikost widgetu pro návrhy se teď dá měnit.",
"suggest.preview": "Určuje, jestli se má v editoru zobrazit náhled výsledku návrhu.",
"suggest.selectionMode": "Určuje, jestli se má při zobrazení widgetu vybrat návrh. Všimněte si, že to platí jenom pro automaticky aktivované návrhy (#editor.quickSuggestions# a #editor.suggestOnTriggerCharacters#) a že při explicitním vyvolání se vždy vybere návrh, například pomocí Ctrl+Mezerník.",
"suggest.shareSuggestSelections": "Určuje, jestli se mají zapamatované výběry návrhů sdílet mezi více pracovními prostory a okny (vyžaduje #editor.suggestSelection#).",
"suggest.showIcons": "Určuje, jestli mají být v návrzích zobrazené nebo skryté ikony.",
"suggest.showInlineDetails": "Určuje, jestli se mají podrobnosti návrhů zobrazovat společně s popiskem, nebo jenom ve widgetu podrobností.",
"suggest.showStatusBar": "Určuje viditelnost stavového řádku v dolní části widgetu návrhů.",
"suggest.snippetsPreventQuickSuggestions": "Určuje, jestli má aktivní fragment kódu zakazovat rychlé návrhy.",
"suggestFontSize": "Velikost písma widgetu návrhů. Při nastavení na hodnotu 0 je použita hodnota #editor.fontSize#.",
"suggestLineHeight": "Výška řádku widgetu návrhů. Při nastavení na hodnotu 0 je použita hodnota #editor.lineHeight#. Minimální hodnota je 8.",
"suggestFontSize": "Velikost písma widgetu návrhů. Při nastavení na hodnotu {0} je použita hodnota {1}.",
"suggestLineHeight": "Výška řádku widgetu návrhů. Při nastavení na hodnotu {0} je použita hodnota {1}. Minimální hodnota je 8.",
"suggestOnTriggerCharacters": "Určuje, jestli se mají při napsání aktivačních znaků automaticky zobrazovat návrhy.",
"suggestSelection": "Určuje, jak jsou předvybrány návrhy při zobrazování seznamu návrhů.",
"suggestSelection.first": "Vždy vybrat první návrh",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Zakáže dokončování pomocí tabulátoru.",
"tabCompletion.on": "Pokud je povoleno dokončování pomocí tabulátoru, bude při stisknutí klávesy Tab vložen nejlepší návrh.",
"tabCompletion.onlySnippets": "Dokončovat fragmenty kódu pomocí tabulátoru, pokud se shodují jejich předpony. Tato funkce funguje nejlépe, pokud není povolena možnost quickSuggestions.",
"tabFocusMode": "Určuje, jestli editor přijímá karty nebo je odloží na workbench pro navigaci.",
"unfoldOnClickAfterEndOfLine": "Určuje, jestli kliknutím na prázdný obsah za sbaleným řádkem dojde k rozbalení řádku.",
"unicodeHighlight.allowedCharacters": "Definuje povolené znaky, které se nezvýrazňují.",
"unicodeHighlight.allowedLocales": "Znaky Unicode, které jsou společné v povolených národních prostředích, se nezvýrazňují.",
"unicodeHighlight.ambiguousCharacters": "Určuje, jestli jsou zvýrazněny znaky, které lze zaměnit se základními znaky ASCII, s výjimkou těch, které jsou běžné v aktuálním národním prostředí uživatele.",
"unicodeHighlight.includeComments": "Určuje, jestli se mají znaky v komentářích také zvýrazňovat v Unicode.",
"unicodeHighlight.includeStrings": "Určuje, jestli se mají znaky v řetězcích také zvýrazňovat v Unicode.",
"unicodeHighlight.includeComments": "Určuje, zda mají být znaky v komentářích také předmětem zvýraznění Unicode.",
"unicodeHighlight.includeStrings": "Určuje, zda mají být znaky v řetězcích také předmětem zvýraznění Unicode.",
"unicodeHighlight.invisibleCharacters": "Určuje, jestli jsou zvýrazněny znaky, které si pouze rezervují místo nebo nemají žádnou šířku.",
"unicodeHighlight.nonBasicASCII": "Určuje, jestli jsou zvýrazněny všechny nestandardní znaky ASCII. Za základní ASCII se považují pouze znaky mezi U+0020 a U+007E, tabulátoru, posunu na další řádek a návratu na začátek řádku.",
"unusualLineTerminators": "Odebírat neobvyklé ukončovací znaky řádku, které by mohly způsobovat problémy",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Neobvyklé ukončovací znaky řádku jsou ignorovány.",
"unusualLineTerminators.prompt": "U neobvyklých ukončovacích znaků řádku se zobrazí dotaz na jejich odebrání.",
"useTabStops": "Vkládání a odstraňování prázdných znaků se řídí zarážkami tabulátoru.",
"wordBreak": "Určuje pravidla oddělení slov používaná pro text v čínštině, japonštině nebo korejštině (CJK).",
"wordBreak.keepAll": "Pro text v čínštině, japonštině nebo korejštině (CJK) by se neměly používat oddělení slov. U jiných textů je chování stejné jako normální chování.",
"wordBreak.normal": "Použijte výchozí pravidlo zalomení řádku.",
"wordSeparators": "Znaky, které se použijí jako oddělovače slov při navigaci nebo operacích v textu",
"wordWrap": "Určuje, jak by se měly zalamovat řádky",
"wordWrap.bounded": "Řádky se budou zalamovat při minimálním viewportu (zobrazení) a hodnotě #editor.wordWrapColumn#.",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "Zalomené řádky získají odsazení +1 směrem k nadřazenému objektu.",
"wrappingIndent.none": "Bez odsazení. Zalomené řádky začínají ve sloupci 1.",
"wrappingIndent.same": "Zalomené řádky získají stejné odsazení jako nadřazený objekt.",
"wrappingStrategy": "Řídí algoritmus, který počítá body zalamování.",
"wrappingStrategy": "Řídí algoritmus, který vypočítává body přerušení. Všimněte si, že v režimu přístupnosti se pro nejlepší uživatelský dojem používá pokročilý.",
"wrappingStrategy.advanced": "Deleguje výpočet bodů zalamování na prohlížeč. Je to pomalý algoritmus, který by mohl u velkých souborů způsobit zamrznutí, ve všech případech ale funguje správně.",
"wrappingStrategy.simple": "Předpokládá, že všechny znaky mají stejnou šířku. Jde o rychlý algoritmus, který funguje správně pro neproporcionální písma a určité skripty (například znaky latinky), kde mají piktogramy stejnou šířku."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Barva pozadí neaktivních vodítek párů závorek (6). Vyžaduje povolení párování závorek.",
"editorCodeLensForeground": "Barva popředí pro CodeLens v editoru",
"editorCursorBackground": "Barva pozadí kurzoru v editoru. Umožňuje přizpůsobit barvu znaku překrytého kurzorem bloku.",
"editorDimmedLineNumber": "Barva posledního řádku editoru, když je vlastnost editor.renderFinalNewline nastavená na ztmavenou.",
"editorGhostTextBackground": "Barva pozadí stínového textu v editoru",
"editorGhostTextBorder": "Barva ohraničení stínového textu v editoru",
"editorGhostTextForeground": "Barva popředí stínového textu v editoru",
"editorGutter": "Barva pozadí mezery u okraje editoru. V mezeře u okraje se zobrazují okraje pro piktogramy a čísla řádků.",
"editorIndentGuides": "Barva vodítek odsazení v editoru",
"editorLineNumbers": "Barva čísel řádků v editoru",
"editorOverviewRulerBackground": "Barva pozadí přehledového pravítka editoru. Používá se pouze v případě, že je povolená minimapa, která je umístěná na pravé straně editoru.",
"editorOverviewRulerBackground": "Barva pozadí přehledového pravítka editoru.",
"editorOverviewRulerBorder": "Barva ohraničení přehledového pravítka",
"editorRuler": "Barva pravítek v editoru",
"editorUnicodeHighlight.background": "Barva pozadí použitá ke zvýraznění znaků Unicode.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Stisknutím klávesy Tab v aktuálním editoru přesunete fokus na další prvek, který může mít fokus. Příkaz {0} nelze aktuálně aktivovat pomocí klávesové zkratky.",
"toggleHighContrast": "Přepnout motiv s vysokým kontrastem"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} znaky",
"showMore": "Zobrazit více ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Ukotvení nastavené na {0}:{1}",
"cancelSelectionAnchor": "Zrušit ukotvení výběru",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Kopírovat jako",
"miCopy": "&&Kopírovat",
"miCut": "&&Vyjmout",
"miPaste": "&&Vložit"
"miPaste": "&&Vložit",
"share": "Sdílet"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Při aplikování akce kódu došlo k neznámé chybě."
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Při aplikování akce kódu došlo k neznámé chybě.",
"args.schema.apply": "Určuje, kdy se mají aplikovat vrácené akce.",
"args.schema.apply.first": "Vždy použít první vrácenou akci kódu",
"args.schema.apply.ifSingle": "Použít první vrácenou akci kódu, pokud je jediná",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Uspořádat importy",
"quickfix.trigger.label": "Rychlá oprava...",
"refactor.label": "Refaktorovat...",
"refactor.preview.label": "Refaktorovat prostřednictvím Preview",
"source.label": "Zdrojová akce..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Umožňuje povolit nebo zakázat zobrazování záhlaví skupin v nabídce Akce kódu."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Přepsat...",
"codeAction.widget.id.extract": "Extrahovat...",
"codeAction.widget.id.inline": "Vložené...",
"codeAction.widget.id.more": "Další akce...",
"codeAction.widget.id.move": "Přesunout...",
"codeAction.widget.id.quickfix": "Rychlá oprava",
"codeAction.widget.id.source": "Zdrojová akce",
"codeAction.widget.id.surround": "Uzavřít do…"
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Skrývání se zakázalo",
"showMoreActions": "Zobrazit zakázané"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Zobrazit akce kódu",
"codeActionWithKb": "Zobrazit akce kódu ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "&&Přepnout řádkový komentář"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Zobrazit místní nabídku editoru"
"action.showContextMenu.label": "Zobrazit místní nabídku editoru",
"context.minimap.minimap": "Minimapa",
"context.minimap.renderCharacters": "Vykreslit znaky",
"context.minimap.size": "Svislá velikost",
"context.minimap.size.fill": "Vyplnit",
"context.minimap.size.fit": "Přizpůsobit",
"context.minimap.size.proportional": "Proporcionální",
"context.minimap.slider": "Posuvník",
"context.minimap.slider.always": "Vždy",
"context.minimap.slider.mouseover": "Ukazatel myši"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Povolí nebo zakáže spouštění úprav z rozšíření při vložení."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Spouští se obslužné rutiny vložení..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Provést znovu akci kurzoru",
"cursor.undo": "Vrátit zpět akci kurzoru"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Spouští se obslužné rutiny přetažení…"
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Určuje, jestli editor spouští operaci, která se dá zrušit, např. Náhled na odkazy"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Přepíše příznak „Math Case“.\r\nPříznak se neuloží do budoucna.\r\n0: Nedělat nic\r\n1: True\r\n2: False",
"actions.find.preserveCaseOverride": "Přepíše příznak „Preserve Case“.\r\nPříznak se neuloží do budoucna.\r\n0: Nedělat nic\r\n1: True\r\n2: False",
"actions.find.wholeWordOverride": "Přepíše příznak „Match Whole Word“.\r\nPříznak se neuloží do budoucna.\r\n0: Nedělat nic\r\n1: True\r\n2: False",
"findMatchAction.goToMatch": "Přejít na shodu…",
"findMatchAction.inputPlaceHolder": "Zadejte číslo pro přechod na konkrétní shodu (mezi 1 a {0})",
"findMatchAction.inputValidationMessage": "Zadejte číslo mezi 1 a {0}.",
"findNextMatchAction": "Najít další",
"findPreviousMatchAction": "Najít předchozí",
"miFind": "&&Najít",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Zvýrazněno je pouze několik prvních výsledků ({0}), ale všechny operace hledání fungují na celém textu."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Barva ovládacího prvku pro sbalení v mezeře u okraje editoru",
"createManualFoldRange.label": "Vytvořit rozsah sbalení z výběru",
"foldAction.label": "Sbalit",
"foldAllAction.label": "Sbalit vše",
"foldAllBlockComments.label": "Sbalit všechny komentáře k bloku",
"foldAllExcept.label": "Sbalit všechny oblasti kromě vybraných",
"foldAllMarkerRegions.label": "Sbalit všechny oblasti",
"foldBackgroundBackground": "Barva pozadí za sbalenými rozsahy. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod tím.",
"foldLevelAction.label": "Sbalit úroveň {0}",
"foldRecursivelyAction.label": "Sbalit rekurzivně",
"gotoNextFold.label": "Přejít na další rozsah sbalení",
"gotoParentFold.label": "Přejít na nadřazenou část",
"gotoPreviousFold.label": "Přejít na předchozí rozsah sbalení",
"maximum fold ranges": "Počet posunutelných oblastí je omezen na maximálně {0}. Zvyšte možnost konfigurace [„Maximální počet posunutelných oblastí“](command:workbench.action.openSettings?[\"editor.foldingMaximumRegions\"]) a povolte jich tak více.",
"removeManualFoldingRanges.label": "Odebrat rozsahy manuálního sbalení",
"toggleFoldAction.label": "Přepnout sbalení",
"unFoldRecursivelyAction.label": "Rozbalit rekurzivně",
"unfoldAction.label": "Rozbalit",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Rozbalit všechny oblasti"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Barva ovládacího prvku pro sbalení v mezeře u okraje editoru",
"foldBackgroundBackground": "Barva pozadí za sbalenými rozsahy. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod tím.",
"foldingCollapsedIcon": "Ikona pro sbalené rozsahy v okraji piktogramu editoru",
"foldingExpandedIcon": "Ikona pro rozbalené rozsahy v okraji piktogramu editoru"
"foldingExpandedIcon": "Ikona pro rozbalené rozsahy v okraji piktogramu editoru",
"foldingManualCollapedIcon": "Ikona pro manuálně sbalené rozsahy v okraji piktogramu editoru.",
"foldingManualExpandedIcon": "Ikona pro manuálně rozbalené rozsahy v okraji piktogramu editoru."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Zvětšení písma editoru",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Načítání...",
"stopped rendering": "Vykreslování bylo z důvodů výkonu pozastaveno z důvodu dlouhé čáry. To se dá nakonfigurovat přes editor.stopRenderingLineAfter.",
"too many characters": "U dlouhých řádků je tokenizace z důvodu výkonu vynechána. Toto je možné nakonfigurovat prostřednictvím nastavení editor.maxTokenizationLineLength."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Zobrazit problém"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Změnit velikost zobrazení tabulátoru",
"configuredTabSize": "Nakonfigurovaná velikost tabulátoru",
"currentTabSize": "Aktuální velikost tabulátoru",
"defaultTabSize": "Výchozí velikost tabulátoru",
"detectIndentation": "Zjistit odsazení z obsahu",
"editor.reindentlines": "Znovu odsadit řádky",
"editor.reindentselectedlines": "Znovu odsadit vybrané řádky",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd + kliknutí"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Přijmout",
"acceptWord": "Přijmout slovo",
"action.inlineSuggest.accept": "Přijmout vložený návrh",
"action.inlineSuggest.acceptNextWord": "Přijmout další vložené slovo návrhu",
"action.inlineSuggest.alwaysShowToolbar": "Vždy zobrazit panel nástrojů",
"action.inlineSuggest.hide": "Hide Inline Suggestion (Skrýt vložený návrh)",
"action.inlineSuggest.showNext": "Zobrazit další vložený návrh",
"action.inlineSuggest.showPrevious": "Zobrazit předchozí vložený návrh",
"action.inlineSuggest.trigger": "Aktivovat vložený návrh",
"action.inlineSuggest.undo": "Vrátit zpět akci Přijmout slovo",
"alwaysShowInlineSuggestionToolbar": "Určuje, jestli má být panel nástrojů vložených návrhů vždy viditelný.",
"canUndoInlineSuggestion": "Určuje, jestli má vrácení vrátit vložený návrh zpět.",
"inlineSuggestionHasIndentation": "Určuje, jestli vložený návrh začíná prázdným znakem.",
"inlineSuggestionHasIndentationLessThanTabSize": "Určuje, zda vložený návrh začíná mezerou, která je menší, než jaká by byla vložena tabulátorem",
"inlineSuggestionVisible": "Určuje, jestli je vložený návrh viditelný."
"inlineSuggestionVisible": "Určuje, jestli je vložený návrh viditelný.",
"undoAcceptWord": "Vrátit zpět akci Přijmout slovo"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Návrh:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Další",
"parameterHintsNextIcon": "Ikona pro zobrazení další nápovědy k parametru",
"parameterHintsPreviousIcon": "Ikona pro zobrazení předchozí nápovědy k parametru",
"previous": "Předchozí"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Nahradit další hodnotou",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Duplikovat výběr",
"editor.transformToCamelcase": "Převést na Camel Case",
"editor.transformToKebabcase": "Převést na Kebab Case",
"editor.transformToLowercase": "Převést na malá písmena",
"editor.transformToSnakecase": "Převést na slova oddělená podtržítkem",
"editor.transformToTitlecase": "Převést na všechna první velká",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Provést příkaz {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Nelze upravovat v editoru jen pro čtení.",
"messageVisible": "Určuje, jestli editor v tuto chvíli zobrazuje vloženou zprávu."
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Přesunout poslední výběr na předchozí nalezenou shodu",
"mutlicursor.addCursorsToBottom": "Přidat kurzory na konec",
"mutlicursor.addCursorsToTop": "Přidat kurzory na začátek",
"mutlicursor.focusNextCursor": "Přepnout fokus na další kurzor",
"mutlicursor.focusNextCursor.description": "Fokus na dalším kurzoru",
"mutlicursor.focusPreviousCursor": "Přepnout fokus na předchozí kurzor",
"mutlicursor.focusPreviousCursor.description": "Fokus na předchozím kurzoru",
"mutlicursor.insertAbove": "Přidat kurzor nad",
"mutlicursor.insertAtEndOfEachLineSelected": "Přidat kurzory na konce řádků",
"mutlicursor.insertBelow": "Přidat kurzor pod",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Barva pozadí mezery u okraje v editoru náhledu",
"peekViewEditorMatchHighlight": "Barva zvýraznění shody v editoru náhledu",
"peekViewEditorMatchHighlightBorder": "Ohraničení zvýraznění shody v editoru náhledu",
"peekViewEditorStickScrollBackground": "Barva pozadí rychlého posouvání v editoru zobrazení náhledu.",
"peekViewResultsBackground": "Barva pozadí seznamu výsledků náhledu",
"peekViewResultsFileForeground": "Barva popředí pro uzly souborů v seznamu výsledků zobrazení náhledu",
"peekViewResultsMatchForeground": "Barva popředí pro uzly řádků v seznamu výsledků zobrazení náhledu",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "parametry typu ({0})",
"variable": "proměnné ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Nelze upravovat v editoru jen pro čtení.",
"editor.simple.readonly": "Nelze upravovat ve vstupu jen pro čtení"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "Úspěšné přejmenování {0} na {1}. Souhrn: {2}",
"enablePreview": "Povolit nebo zakázat možnost zobrazení náhledu změn před přejmenováním",
"label": "Přejmenovává se {0}.",
"label": "Přejmenování {0} na {1}",
"no result": "Žádný výsledek",
"quotableLabel": "Přejmenovává se {0}.",
"quotableLabel": "{0} se přejmenovává na {1}.",
"rename.failed": "Při přejmenovávání se nepovedlo vypočítat úpravy.",
"rename.failedApply": "Při přejmenovávání se nepovedlo aplikovat úpravy.",
"rename.label": "Přejmenovat symbol",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Určuje, jestli je v režimu fragmentu kódu další zarážka tabulátoru.",
"hasPrevTabstop": "Určuje, jestli je v režimu fragmentu kódu předchozí zarážka tabulátoru.",
"inSnippetMode": "Určuje, jestli je editor aktuálně v režimu fragmentu kódu."
"inSnippetMode": "Určuje, jestli je editor aktuálně v režimu fragmentu kódu.",
"next": "Přejít na další zástupný symbol…"
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Duben",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Středa",
"WednesdayShort": "St"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Rychlé posouvání",
"mitoggleStickyScroll": "&&Přepnout rychlé posouvání",
"stickyScroll": "Rychlé posouvání",
"toggleStickyScroll": "Přepnout rychlé posouvání"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Určuje, jestli se při stisknutí klávesy Enter vkládají návrhy.",
"suggestWidgetDetailsVisible": "Určuje, jestli jsou viditelné podrobnosti návrhů.",
"suggestWidgetHasSelection": "Určuje, jestli má nějaký návrh fokus.",
"suggestWidgetMultipleSuggestions": "Určuje, jestli existuje více návrhů, ze kterých se dá vybírat.",
"suggestionCanResolve": "Určuje, jestli aktuální návrh podporuje řešení dalších podrobností.",
"suggestionHasInsertAndReplaceRange": "Určuje, jestli aktuální návrh má chování vkládání a nahrazování.",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Ikona pro další informace ve widgetu pro návrhy"
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Barva popředí pro symboly array. Tyto symboly se zobrazují ve widgetu osnovy, popisu cesty a návrhů.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "Soubor {0} obsahuje minimálně jeden neobvyklý ukončovací znak řádku, jako je oddělovač řádků (LS) nebo oddělovač odstavců (PS). \r\n\r\nDoporučujeme je odebrat ze souboru. Lze to nakonfigurovat prostřednictvím nastavení editor.unusualLineTerminators.",
"unusualLineTerminators.fix": "Odstranit neobvyklé ukončovací znaky řádku",
"unusualLineTerminators.fix": "&&Odstranit neobvyklé ukončovací znaky řádku",
"unusualLineTerminators.ignore": "Ignorovat",
"unusualLineTerminators.message": "Zjištěny neobvyklé ukončovací znaky řádku",
"unusualLineTerminators.title": "Neobvyklé ukončovací znaky řádku"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Barva značky přehledového pravítka pro zvýraznění symbolů. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod tím.",
"overviewRulerWordHighlightStrongForeground": "Barva značky přehledového pravítka pro zvýraznění symbolů s oprávněním k zápisu. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod tím.",
"overviewRulerWordHighlightTextForeground": "Barva značky přehledového pravítka textového výskytu symbolu. Barva nesmí být neprůhledná, aby se nepřekryly dekorace.",
"wordHighlight": "Barva pozadí symbolu při čtení, například při čtení proměnné. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod tím.",
"wordHighlight.next.label": "Přejít na další zvýraznění symbolu",
"wordHighlight.previous.label": "Přejít na předchozí zvýraznění symbolu",
"wordHighlight.trigger.label": "Aktivovat zvýraznění symbolů",
"wordHighlightBorder": "Barva ohraničení symbolu při čtení, například při čtení proměnné",
"wordHighlightStrong": "Barva pozadí symbolu při zápisu, například při zápisu proměnné. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod tím.",
"wordHighlightStrongBorder": "Barva ohraničení symbolu při zápisu, například při zápisu do proměnné"
"wordHighlightStrongBorder": "Barva ohraničení symbolu při zápisu, například při zápisu do proměnné",
"wordHighlightText": "Barva pozadí textového výskytu symbolu. Barva nesmí být neprůhledná, aby se nepřekryly dekorace.",
"wordHighlightTextBorder": "Barva ohraničení textového výskytu symbolu."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Přejít na další zvýraznění symbolu",
"wordHighlight.previous.label": "Přejít na předchozí zvýraznění symbolu",
"wordHighlight.trigger.label": "Aktivovat zvýraznění symbolů"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Odstranit slovo"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Vývojář",
"help": "Nápověda",
"preferences": "Předvolby",
"test": "Test",
"view": "Zobrazit"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Skrýt",
"resetThisMenu": "Obnovit nabídku"
},
"vs/platform/actions/common/menuService": {
"hide.label": "Skrýt {0}"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Widget akce",
"customQuickFixWidget.labels": "{0}, důvod zakázání: {1}",
"label": "použít {0}",
"label-preview": "{0} pro použití, {1} pro verzi preview"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Přijmout vybranou akci",
"codeActionMenuVisible": "Určuje, jestli je seznam widgetů akcí viditelný.",
"hideCodeActionWidget.title": "Skrýt widget akcí",
"previewSelected.title": "Zobrazit náhled vybrané akce",
"selectNextCodeAction.title": "Vybrat další akci",
"selectPrevCodeAction.title": "Vybrat předchozí akci"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Rozdílový řádek odstraněn",
"audioCues.diffLineInserted": "Vložen rozdílový řádek",
"audioCues.diffLineModified": "Rozdílný řádek změněn",
"audioCues.lineHasBreakpoint.name": "Zarážka na řádku",
"audioCues.lineHasError.name": "Chyba na řádku",
"audioCues.lineHasFoldedArea.name": "Složená oblast na řádku",
"audioCues.lineHasInlineSuggestion.name": "Vložený návrh na řádku",
"audioCues.lineHasWarning.name": "Upozornění na řádku",
"audioCues.noInlayHints": "Žádné tipy pro vložené položky na řádku",
"audioCues.notebookCellCompleted": "Buňka poznámkového bloku dokončena",
"audioCues.notebookCellFailed": "Buňka poznámkového bloku selhala.",
"audioCues.onDebugBreak.name": "Ladicí program se zastavil na zarážce.",
"audioCues.taskCompleted": "Úloha dokončena",
"audioCues.taskFailed": "Úloha se nezdařila",
"audioCues.terminalBell": "Zvonek terminálu",
"audioCues.terminalCommandFailed": "Příkaz terminálu se nezdařil.",
"audioCues.terminalQuickFix.name": "Rychlá oprava terminálu"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "Nelze zaregistrovat {0}. Přidružená zásada {1} je už zaregistrovaná v {2}.",
"config.property.duplicate": "Nelze zaregistrovat {0}. Tato vlastnost už je zaregistrovaná.",
"config.property.empty": "Nejde zaregistrovat prázdnou vlastnost.",
"config.property.languageDefault": "Nelze zaregistrovat {0}. Odpovídá to vzoru vlastnosti \\\\ [. * \\\\]$ pro popis nastavení editoru specifického pro daný jazyk. Použijte příspěvek configurationDefaults.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Určuje, jestli je operačním systémem Linux.",
"isMac": "Určuje, jestli je operačním systémem macOS.",
"isMacNative": "Určuje, jestli je operačním systémem macOS na platformě bez prohlížeče.",
"isMobile": "Jestli je platforma mobilní webový prohlížeč",
"isWeb": "Určuje, jestli je daná platforma webový prohlížeč.",
"isWindows": "Určuje, jestli je operačním systémem Windows."
"isWindows": "Určuje, jestli je operačním systémem Windows.",
"productQualityType": "Typ kvality VS Code"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Zrušit",
"moreFile": "...nezobrazuje se 1 další soubor",
"moreFiles": "...nezobrazuje se několik dalších souborů (celkem {0})"
"moreFiles": "...nezobrazuje se několik dalších souborů (celkem {0})",
"okButton": "&&OK",
"yesButton": "&&Ano"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "Soubor je příliš velký na to, aby se dal otevřít v editoru bez názvu. Nahrajte prosím tento soubor nejdříve do Průzkumníka souborů a pak to zkuste znovu."
},
"vs/platform/files/common/files": {
"sizeB": "{0} B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Multiplikátor rychlosti posouvání při podržené klávese Alt",
"Mouse Wheel Scroll Sensitivity": "Multiplikátor, který se má použít pro hodnoty deltaX a deltaY událostí posouvání kolečka myši",
"automatic keyboard navigation setting": "Určuje, jestli se automaticky spustí navigace pomocí klávesnice v seznamech a stromech, když začnete psát. Pokud je nastaveno na false, navigace pomocí klávesnice se spustí pouze při provedení příkazu list.toggleKeyboardNavigation, ke kterému lze přiřadit klávesovou zkratku.",
"defaultFindMatchTypeSettingKey": "Určuje typ shody, který se používá při vyhledávání seznamů a stromů na pracovní ploše.",
"defaultFindMatchTypeSettingKey.contiguous": "Při hledání použijte souvislou shodu.",
"defaultFindMatchTypeSettingKey.fuzzy": "Při hledání použijte přibližné shody.",
"defaultFindModeSettingKey": "Ovládá výchozí režim vyhledávání pro seznamy a stromy v pracovní ploše.",
"defaultFindModeSettingKey.filter": "Umožňuje filtrovat elementy při hledání.",
"defaultFindModeSettingKey.highlight": "Zvýraznění prvků při vyhledávání. Další navigace nahoru a dolů prochází pouze zvýrazněné prvky.",
"expand mode": "Určuje, jak se stromové složky rozbalují, když se klikne na jejich název. Poznámka: Některé stromy a seznamy můžou toto nastavení ignorovat, pokud se nedá použít.",
"horizontalScrolling setting": "Určuje, jestli seznamy a stromy podporují vodorovné posouvání na pracovní ploše. Upozornění: Povolení tohoto nastavení má vliv na výkon.",
"keyboardNavigationSettingKey": "Určuje styl navigace pomocí klávesnice pro seznamy a stromy na pracovní ploše. Lze použít tyto styly navigace: jednoduchý, zvýraznění a filtr.",
"keyboardNavigationSettingKey.filter": "Funkce filtrování navigace pomocí klávesnice odfiltruje a skryje všechny elementy, které neodpovídají vstupu z klávesnice.",
"keyboardNavigationSettingKey.highlight": "Funkce zvýraznění navigace pomocí klávesnice zvýrazní elementy, které odpovídají vstupu z klávesnice. Při další navigaci nahoru a dolů se bude navigovat pouze po zvýrazněných elementech.",
"keyboardNavigationSettingKey.simple": "Při jednoduché navigaci pomocí klávesnice se fokus přesouvá na elementy, které odpovídají vstupu z klávesnice. Shoda se vyhledává pouze podle předpon.",
"keyboardNavigationSettingKeyDeprecated": "Místo toho prosím použijte workbench.list.defaultFindMode a workbench.list.typeNavigationMode.",
"list smoothScrolling setting": "Určuje, jestli se budou seznamy a stromy posouvat plynule.",
"list.scrollByPage": "Určuje, zda bude kliknutí na stránce posuvníku posunuto po stránce.",
"multiSelectModifier": "Modifikátor, který se má použít k přidání položky do stromů a seznamů při výběru více položek myší (například v průzkumníkovi, otevřených editorech a zobrazení scm). Gesta myší Otevřít na boku (pokud jsou podporována) se upraví tak, aby nebyla s modifikátorem vícenásobného výběru v konfliktu.",
"multiSelectModifier.alt": "Mapuje se na klávesu Alt ve Windows a Linuxu a na klávesu Option v macOS.",
"multiSelectModifier.ctrlCmd": "Mapuje se na klávesu Control ve Windows a Linuxu a na klávesu Command v macOS.",
"openModeModifier": "Určuje, jak se mají otevírat položky ve stromech a seznamech pomocí myši (pokud je podporováno). Poznámka: Některé stromy a seznamy mohou toto nastavení ignorovat, pokud není relevantní.",
"render tree indent guides": "Určuje, jestli se mají ve stromu vykreslovat vodítka odsazení.",
"tree indent setting": "Určuje odsazení stromu v pixelech.",
"typeNavigationMode": "Určuje, jak funguje navigace typu v seznamech a stromech na pracovní ploše. Když se nastaví na trigger, navigace typu se spustí po spuštění příkazu list.triggerTypeNavigation.",
"workbenchConfigurationTitle": "Pracovní plocha"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Upozornění"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "Výsledkem příkazu {0} je chyba ({1}).",
"canNotRun": "Výsledkem příkazu {0} je chyba.",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "běžně používané",
"morecCommands": "další příkazy",
"recentlyUsed": "naposledy použité"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "příkazy editoru",
"globalCommands": "globální příkazy",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Vlastní",
"inputModeEntry": "Stisknutím klávesy Enter potvrdíte vstup. Klávesou Esc akci zrušíte.",
"inputModeEntryDescription": "{0} (Potvrdíte stisknutím klávesy Enter. Zrušíte klávesou Esc.)",
"ok": "OK",
"quickInput.back": "Zpět",
"quickInput.backWithKeybinding": "Zpět ({0})",
"quickInput.checkAll": "Přepnout všechna zaškrtávací políčka",
"quickInput.countSelected": "Vybrané: {0}",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "Počet výsledků: {0}",
"quickInputBox.ariaLabel": "Pokud chcete zúžit počet výsledků, začněte psát."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Rychlý vstup"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Kliknutím provedete příkaz {0}."
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Dodatečné ohraničení kolem aktivních prvků, které je odděluje od ostatních prvků za účelem zvýšení kontrastu",
"activeLinkForeground": "Barva aktivních odkazů",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Barva pozadí položek s popisem cesty",
"breadcrumbsFocusForeground": "Barva položek s popisem cesty, které mají fokus",
"breadcrumbsSelectedBackground": "Barva pozadí ovládacího prvku pro výběr položky s popisem cesty",
"breadcrumbsSelectedForegound": "Barva vybraných položek s popisem cesty",
"breadcrumbsSelectedForeground": "Barva vybraných položek s popisem cesty",
"buttonBackground": "Barva pozadí tlačítka",
"buttonBorder": "Barva ohraničení tlačítka",
"buttonForeground": "Barva popředí tlačítka",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Barva pozadí sekundárního tlačítka",
"buttonSecondaryForeground": "Barva popředí sekundárního tlačítka",
"buttonSecondaryHoverBackground": "Barva pozadí sekundárního tlačítka při umístění ukazatele myši",
"buttonSeparator": "Barva oddělovače tlačítek.",
"chartsBlue": "Modrá barva používaná ve vizualizacích grafů",
"chartsForeground": "Barva popředí použitá v grafech",
"chartsGreen": "Zelená barva používaná ve vizualizacích grafů",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Barva pozadí widgetu zaškrtávacího políčka",
"checkbox.border": "Barva ohraničení widgetu zaškrtávacího políčka",
"checkbox.foreground": "Barva popředí widgetu zaškrtávacího políčka",
"checkbox.select.background": "Barva pozadí widgetu zaškrtávacího políčka, když je vybraný prvek, ve kterém se nachází.",
"checkbox.select.border": "Barva ohraničení widgetu zaškrtávacího políčka, když je vybraný prvek, ve kterém se nachází.",
"contrastBorder": "Dodatečné ohraničení kolem prvků, které je odděluje od ostatních prvků za účelem zvýšení kontrastu",
"descriptionForeground": "Barva popředí textu popisu, který poskytuje další informace, například pro popisek",
"diffDiagonalFill": "Barva diagonální výplně editoru rozdílů. Diagonální výplň se používá v zobrazeních se zobrazením rozdílů vedle sebe.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Barva pozadí okraje, ze kterého byly odebrány řádky.",
"diffEditorRemovedLines": "Barva pozadí řádků, které byly odebrány. Barva nesmí být neprůhledná, aby neskrývala podkladové dekorace.",
"diffEditorRemovedOutline": "Barva obrysu pro text, který byl odebrán",
"disabledForeground": "Celkové popředí pro zakázané elementy. Tato barva se použije jenom v případě, že není přepsaná komponentou.",
"dropdownBackground": "Pozadí rozevíracího seznamu",
"dropdownBorder": "Ohraničení rozevíracího seznamu",
"dropdownForeground": "Popředí rozevíracího seznamu",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Barva vybraného textu pro vysoký kontrast",
"editorSelectionHighlight": "Barva pro oblasti se stejným obsahem jako výběr. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod tím.",
"editorSelectionHighlightBorder": "Barva ohraničení pro oblasti se stejným obsahem jako výběr",
"editorStickyScrollBackground": "Barva pozadí rychlého posouvání pro editor",
"editorStickyScrollHoverBackground": "Barva pozadí rychlého posouvání při najetí myší pro editor",
"editorWarning.background": "Barva pozadí textu upozornění v editoru. Barva nesmí být neprůhledná, aby se nepřekryly dekorace pod upozorněním.",
"editorWarning.foreground": "Barva popředí podtržení upozornění vlnovkou v editoru",
"editorWidgetBackground": "Barva pozadí widgetů editoru, například najít/nahradit",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Barva pozadí widgetu filtru typu v seznamech a stromech",
"listFilterWidgetNoMatchesOutline": "Barva obrysu widgetu filtrování typů v seznamech a stromech, pokud neexistují žádné shody",
"listFilterWidgetOutline": "Barva obrysu widgetu filtrování typů v seznamech a stromech",
"listFilterWidgetShadow": "Barva stínování widgetu filtru typu v seznamech a stromech.",
"listFocusAndSelectionOutline": "Barva obrysu seznamu nebo stromu pro položku s fokusem, pokud je seznam nebo strom aktivní a vybraný. Aktivní seznam nebo strom má fokus klávesnice, neaktivní nikoli.",
"listFocusBackground": "Barva pozadí seznamu nebo stromu pro položku s fokusem, pokud je seznam nebo strom aktivní. Aktivní seznam nebo strom má fokus klávesnice, neaktivní nikoli.",
"listFocusForeground": "Popředí seznamu nebo stromu pro položku s fokusem, pokud je seznam nebo strom aktivní. Aktivní seznam nebo strom má fokus klávesnice, neaktivní nikoli.",
"listFocusHighlightForeground": "Barva popředí seznamu nebo stromu pro zvýraznění shody u položek s aktivním fokusem při vyhledávání v rámci seznamu nebo stromu",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Pozadí panelu nástrojů při podržení myši nad akcemi",
"toolbarHoverBackground": "Pozadí panelu nástrojů při najetí myší na akce",
"toolbarHoverOutline": "Obrys panelu nástrojů při najetí myší na akce",
"treeInactiveIndentGuidesStroke": "Barva tahu stromu pro vodítka odsazení, která nejsou aktivní.",
"treeIndentGuidesStroke": "Barva tahu stromu pro vodítka odsazení",
"warningBorder": "Barva ohraničení polí upozornění v editoru",
"widgetBorder": "Barva ohraničení widgetů, například pro hledání/nahrazení v rámci editoru.",
"widgetShadow": "Barva stínu widgetů, například pro hledání/nahrazení v rámci editoru"
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Ikona pro akci zavření ve widgetech"
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Zrušit",
"cannotResourceRedoDueToInProgressUndoRedo": "Akci {0} se nepovedlo znovu provést, protože už běží jiná operace vrácení zpět nebo opětovného provedení.",
"cannotResourceUndoDueToInProgressUndoRedo": "Akci {0} se nepovedlo vrátit zpět, protože už běží jiná operace vrácení zpět nebo opětovného provedení.",
"cannotWorkspaceRedo": "Akci {0} se nepovedlo znovu provést u všech souborů. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "Akci {0} se nepovedlo vrátit zpět u všech souborů, protože už běží jiná operace vrácení zpět nebo opětovného provedení pro tyto soubory: {1}.",
"confirmDifferentSource": "Chcete vrátit akci {0}?",
"confirmDifferentSource.no": "Ne",
"confirmDifferentSource.yes": "Ano",
"confirmDifferentSource.yes": "&&Ano",
"confirmWorkspace": "Chcete vrátit zpět akci {0} u všech souborů?",
"externalRemoval": "Na disku byly zavřeny a upraveny následující soubory: {0}.",
"noParallelUniverses": "Následující soubory byly upraveny nekompatibilním způsobem: {0}.",
"nok": "Vrátit tento soubor zpět",
"ok": "Vrátit zpět tento počet souborů: {0}"
"nok": "Vrátit tento &&soubor zpět",
"ok": "&&Vrátit zpět tento počet souborů: {0}"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Pracovní prostor Code"

398
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/de.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Weitere Aktionen..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Dialogfeld schließen",
"dialogErrorMessage": "Fehler",
"dialogInfoMessage": "Info",
"dialogPendingMessage": "In Bearbeitung",
"dialogWarningMessage": "Warnung",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Weitere Aktionen..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "Eingabe"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Groß-/Kleinschreibung beachten",
"regexDescription": "Regulären Ausdruck verwenden",
"wordsDescription": "Nur ganzes Wort suchen"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "Eingabe",
"label.preserveCaseToggle": "Groß-/Kleinschreibung beibehalten"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Ungebunden"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Auswahlfeld"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Weitere Aktionen..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Löschen",
"disable filter on type": "Typfilter deaktivieren",
"empty": "Keine Elemente gefunden",
"enable filter on type": "Typfilter aktivieren",
"found": "{0} von {1} Elementen stimmen überein"
"close": "Schließen",
"filter": "Filter",
"fuzzySearch": "Fuzzyübereinstimmung",
"not found": "Kein Element gefunden.",
"type to filter": "Zum Filtern Text eingeben",
"type to search": "Zum Suchen eingeben"
},
"vs/base/common/actions": {
"submenu.empty": "(leer)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Benutzerdefiniert",
"inputModeEntry": "Drücken Sie die EINGABETASTE, um Ihre Eingabe zu bestätigen, oder ESC, um den Vorgang abzubrechen.",
"inputModeEntryDescription": "{0} (Drücken Sie die EINGABETASTE zur Bestätigung oder ESC, um den Vorgang abzubrechen.)",
"ok": "OK",
"quickInput.back": "Zurück",
"quickInput.backWithKeybinding": "Zurück ({0})",
"quickInput.countSelected": "{0} ausgewählt",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} Ergebnisse",
"quickInputBox.ariaLabel": "Nehmen Sie eine Eingabe vor, um die Ergebnisse einzugrenzen."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Schnelleingabe"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "Auf den Editor kann derzeit nicht zugegriffen werden. Drücken Sie {0}, um die Optionen anzuzeigen.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Rückgängig"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "Die Anzahl der Cursors wurde auf {0} beschränkt."
"cursors.maximum": "Die Anzahl der Cursor wurde auf {0} beschränkt. Erwägen Sie die Verwendung von [Suchen und Ersetzen](https://code.visualstudio.com/docs/editor/codebasics#_find-und-ersetzen) für größere Änderungen, oder erhöhen Sie die Multicursorbegrenzungseinstellung des Editors.",
"goToSetting": "Erhöhen des Grenzwerts für mehrere Cursor"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " verwenden Sie UMSCHALT+F7, um durch Änderungen zu navigieren.",
"diff.tooLarge": "Kann die Dateien nicht vergleichen, da eine Datei zu groß ist.",
"diffInsertIcon": "Zeilenformatierung für Einfügungen im Diff-Editor",
"diffRemoveIcon": "Zeilenformatierung für Entfernungen im Diff-Editor"
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Steuert, ob der Editor CodeLens anzeigt.",
"detectIndentation": "Steuert, ob \"#editor.tabSize#\" und \"#editor.insertSpaces#\" automatisch erkannt werden, wenn eine Datei basierend auf dem Dateiinhalt geöffnet wird.",
"detectIndentation": "Steuert, ob {0} und {1} automatisch erkannt werden, wenn eine Datei basierend auf dem Dateiinhalt geöffnet wird.",
"diffAlgorithm.experimental": "Verwendet einen experimentellen Vergleichsalgorithmus.",
"diffAlgorithm.smart": "Verwendet den Standardvergleichsalgorithmus.",
"editor.experimental.asyncTokenization": "Steuert, ob die Tokenisierung asynchron auf einem Webworker erfolgen soll.",
"editorConfigurationTitle": "Editor",
"ignoreTrimWhitespace": "Wenn aktiviert, ignoriert der Diff-Editor Änderungen an voran- oder nachgestellten Leerzeichen.",
"insertSpaces": "Fügt beim Drücken der TAB-Taste Leerzeichen ein. Diese Einstellung wird basierend auf dem Inhalt der Datei überschrieben, wenn \"#editor.detectIndentation#\" aktiviert ist.",
"indentSize": "Die Anzahl von Leerzeichen, die für den Einzug oder „tabSize“ verwendet werden, um den Wert aus „#editor.tabSize#“ zu verwenden. Diese Einstellung wird basierend auf dem Dateiinhalt überschrieben, wenn „#editor.detectIndentation#“ aktiviert ist.",
"insertSpaces": "Fügt beim Drücken der TAB-Taste Leerzeichen ein. Diese Einstellung wird basierend auf dem Inhalt der Datei überschrieben, wenn {0} aktiviert ist.",
"largeFileOptimizations": "Spezielle Behandlung für große Dateien zum Deaktivieren bestimmter speicherintensiver Funktionen.",
"maxComputationTime": "Timeout in Millisekunden, nach dem die Diff-Berechnung abgebrochen wird. Bei 0 wird kein Timeout verwendet.",
"maxFileSize": "Maximale Dateigröße in MB, für die Diffs berechnet werden sollen. Verwenden Sie 0, um keinen Grenzwert zu setzen.",
"maxTokenizationLineLength": "Zeilen, die diese Länge überschreiten, werden aus Leistungsgründen nicht tokenisiert",
"renderIndicators": "Steuert, ob der Diff-Editor die Indikatoren \"+\" und \"-\" für hinzugefügte/entfernte Änderungen anzeigt.",
"renderMarginRevertIcon": "Wenn diese Option aktiviert ist, zeigt der Diff-Editor Pfeile in seinem Glyphenrand an, um Änderungen rückgängig zu machen.",
"schema.brackets": "Definiert die Klammersymbole, die den Einzug vergrößern oder verkleinern.",
"schema.closeBracket": "Das schließende Klammerzeichen oder die Zeichenfolgensequenz.",
"schema.colorizedBracketPairs": "Definiert die Klammerpaare, die durch ihre Schachtelungsebene farbig formatiert werden, wenn die Farbgebung für das Klammerpaar aktiviert ist.",
@ -139,15 +160,15 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.false": "Die semantische Hervorhebung ist für alle Farbdesigns deaktiviert.",
"semanticHighlighting.true": "Die semantische Hervorhebung ist für alle Farbdesigns aktiviert.",
"sideBySide": "Steuert, ob der Diff-Editor die Unterschiede nebeneinander oder im Text anzeigt.",
"stablePeek": "Peek-Editoren geöffnet lassen, auch wenn auf den Inhalt doppelgeklickt oder die ESC-TASTE gedrückt wird.",
"tabSize": "Die Anzahl der Leerzeichen, denen ein Tabstopp entspricht. Diese Einstellung wird basierend auf dem Inhalt der Datei überschrieben, wenn \"#editor.detectIndentation#\" aktiviert ist.",
"stablePeek": "Lassen Sie Peek-Editoren geöffnet, auch wenn Sie auf ihren Inhalt doppelklicken oder auf die ESCAPETASTE klicken.",
"tabSize": "Die Anzahl der Leerzeichen, denen ein Tabstopp entspricht. Diese Einstellung wird basierend auf dem Inhalt der Datei überschrieben, wenn {0} aktiviert ist.",
"trimAutoWhitespace": "Nachfolgende automatisch eingefügte Leerzeichen entfernen",
"wordBasedSuggestions": "Steuert, ob Vervollständigungen auf Grundlage der Wörter im Dokument berechnet werden sollen.",
"wordBasedSuggestionsMode": "Steuert, aus welchen Dokumenten wortbasierte Vervollständigungen berechnet werden.",
"wordBasedSuggestionsMode.allDocuments": "Wörter aus allen geöffneten Dokumenten vorschlagen",
"wordBasedSuggestionsMode.currentDocument": "Nur Wörter aus dem aktiven Dokument vorschlagen",
"wordBasedSuggestionsMode.matchingDocuments": "Wörter aus allen geöffneten Dokumenten derselben Sprache vorschlagen",
"wordWrap.inherit": "Zeilen werden entsprechend der Einstellung \"#editor.wordWrap#\" umbrochen.",
"wordWrap.inherit": "Zeilen werden gemäß der Einstellung „{0}“ umbrochen.",
"wordWrap.off": "Zeilenumbrüche erfolgen nie.",
"wordWrap.on": "Der Zeilenumbruch erfolgt an der Breite des Anzeigebereichs."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Steuert, ob Vorschläge mit der EINGABETASTE (zusätzlich zur TAB-Taste) akzeptiert werden sollen. Vermeidet Mehrdeutigkeit zwischen dem Einfügen neuer Zeilen oder dem Annehmen von Vorschlägen.",
"acceptSuggestionOnEnterSmart": "Einen Vorschlag nur mit der EINGABETASTE akzeptieren, wenn dieser eine Änderung am Text vornimmt.",
"accessibilityPageSize": "Steuert die Anzahl von Zeilen im Editor, die von einer Sprachausgabe in einem Arbeitsschritt gelesen werden können. Wenn eine Sprachausgabe erkannt wird, wird der Standardwert automatisch auf 500 festgelegt. Warnung: Ein Wert höher als der Standardwert, kann sich auf die Leistung auswirken.",
"accessibilitySupport": "Steuert, ob der Editor in einem für die Sprachausgabe optimierten Modus ausgeführt werden soll. Durch Festlegen auf \"Ein\" werden Zeilenumbrüche deaktiviert.",
"accessibilitySupport.auto": "Der Editor verwendet Plattform-APIs, um zu erkennen, wenn eine Sprachausgabe angefügt wird.",
"accessibilitySupport.off": "Der Editor wird nie für die Verwendung mit einer Sprachausgabe optimiert.",
"accessibilitySupport.on": "Der Editor wird dauerhaft für die Verwendung mit einer Sprachausgabe optimiert. Zeilenumbrüche werden deaktiviert.",
"accessibilitySupport": "Steuert, ob die Benutzeroberfläche in einem Modus ausgeführt werden soll, in dem sie für Sprachausgaben optimiert ist.",
"accessibilitySupport.auto": "Plattform-APIs verwenden, um zu erkennen, wenn eine Sprachausgabe angefügt ist",
"accessibilitySupport.off": "Annehmen, dass keine Sprachausgabe angefügt ist",
"accessibilitySupport.on": "Für die Verwendung mit einer Sprachausgabe optimieren",
"alternativeDeclarationCommand": "Die alternative Befehls-ID, die ausgeführt wird, wenn das Ergebnis von \"Gehe zu Deklaration\" der aktuelle Speicherort ist.",
"alternativeDefinitionCommand": "Die alternative Befehls-ID, die ausgeführt wird, wenn das Ergebnis von \"Gehe zu Definition\" die aktuelle Position ist.",
"alternativeImplementationCommand": "Die alternative Befehls-ID, die ausgeführt wird, wenn das Ergebnis von \"Gehe zu Implementatierung\" der aktuelle Speicherort ist.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Steuert, ob der Editor Anführungszeichen automatisch schließen soll, nachdem der Benutzer ein öffnendes Anführungszeichen hinzugefügt hat.",
"autoIndent": "Legt fest, ob der Editor den Einzug automatisch anpassen soll, wenn Benutzer Zeilen eingeben, einfügen, verschieben oder einrücken",
"autoSurround": "Steuert, ob der Editor die Auswahl beim Eingeben von Anführungszeichen oder Klammern automatisch umschließt.",
"bracketPairColorization.enabled": "Steuert, ob die Farbgebung für das Klammerpaar aktiviert ist oder nicht. Verwenden Sie #workbench.colorCustomizations#, um die Hervorhebungsfarben der Klammer außer Kraft zu setzen.",
"bracketPairColorization.enabled": "Steuert, ob die Klammerpaar-Farbgebung aktiviert ist oder nicht. Verwenden Sie {0}, um die Hervorhebungsfarben der Klammer zu überschreiben.",
"bracketPairColorization.independentColorPoolPerBracketType": "Steuert, ob jeder Klammertyp über einen eigenen unabhängigen Farbpool verfügt.",
"codeActions": "Aktiviert das Glühbirnensymbol für Codeaktionen im Editor.",
"codeActions": "Aktiviert das Glühlampensymbol für Codeaktionen im Editor.",
"codeLens": "Steuert, ob der Editor CodeLens anzeigt.",
"codeLensFontFamily": "Steuert die Schriftfamilie für CodeLens.",
"codeLensFontSize": "Steuert den Schriftgrad in Pixeln für CodeLens. Bei Festlegung auf „0“ werden 90 % von „#editor.fontSize#“ verwendet.",
"codeLensFontSize": "Steuert den Schriftgrad in Pixeln für CodeLens. Bei Festlegung auf „0, 90 % von „#editor.fontSize#“ verwendet.",
"colorDecorators": "Steuert, ob der Editor die Inline-Farbdecorators und die Farbauswahl rendern soll.",
"colorDecoratorsLimit": "Steuert die maximale Anzahl von Farb-Decorators, die in einem Editor gleichzeitig gerendert werden können.",
"columnSelection": "Zulassen, dass die Auswahl per Maus und Tasten die Spaltenauswahl durchführt.",
"comments.ignoreEmptyLines": "Steuert, ob leere Zeilen bei Umschalt-, Hinzufügungs- oder Entfernungsaktionen für Zeilenkommentare ignoriert werden sollen.",
"comments.insertSpace": "Steuert, ob beim Kommentieren ein Leerzeichen eingefügt wird.",
"copyWithSyntaxHighlighting": "Steuert, ob Syntax-Highlighting in die Zwischenablage kopiert wird.",
"cursorBlinking": "Steuert den Cursoranimationsstil.",
"cursorSmoothCaretAnimation": "Steuert, ob die weiche Cursoranimation aktiviert werden soll.",
"cursorSmoothCaretAnimation.explicit": "Die Smooth Caret-Animation ist nur aktiviert, wenn der Benutzer den Cursor mit einer expliziten Geste bewegt.",
"cursorSmoothCaretAnimation.off": "Die Smooth Caret-Animation ist deaktiviert.",
"cursorSmoothCaretAnimation.on": "Die Smooth Caret-Animation ist immer aktiviert.",
"cursorStyle": "Steuert den Cursor-Stil.",
"cursorSurroundingLines": "Steuert die Mindestanzahl sichtbarer führender und nachfolgender Zeilen um den Cursor. Dies wird in einigen anderen Editoren als \"scrollOff\" oder \"scrollOffset\" bezeichnet.",
"cursorSurroundingLines": "Steuert die Mindestanzahl sichtbarer führender Zeilen (mindestens 0) und nachfolgender Zeilen (mindestens 1) um den Cursor. Dies wird in einigen anderen Editoren als „scrollOff“ oder „scrollOffset“ bezeichnet.",
"cursorSurroundingLinesStyle": "Legt fest, wann cursorSurroundingLines erzwungen werden soll",
"cursorSurroundingLinesStyle.all": "\"cursorSurroundingLines\" wird immer erzwungen.",
"cursorSurroundingLinesStyle.default": "\"cursorSurroundingLines\" wird nur erzwungen, wenn die Auslösung über die Tastatur oder API erfolgt.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Steuert, ob die Mausgeste \"Gehe zu Definition\" immer das Vorschauwidget öffnet.",
"deprecated": "Diese Einstellung ist veraltet. Verwenden Sie stattdessen separate Einstellungen wie \"editor.suggest.showKeywords\" oder \"editor.suggest.showSnippets\".",
"dragAndDrop": "Steuert, ob der Editor das Verschieben einer Auswahl per Drag and Drop zulässt.",
"dropIntoEditor.enabled": "Steuert, ob Sie eine Datei in einen Editor ziehen und ablegen können, indem Sie die UMSCHALTTASTE gedrückt halten (anstatt die Datei in einem Editor zu öffnen).",
"editor.autoClosingBrackets.beforeWhitespace": "Schließe Klammern nur automatisch, wenn der Cursor sich links von einem Leerzeichen befindet.",
"editor.autoClosingBrackets.languageDefined": "Verwenden Sie Sprachkonfigurationen, um zu bestimmen, wann Klammern automatisch geschlossen werden sollen.",
"editor.autoClosingDelete.auto": "Angrenzende schließende Anführungszeichen oder Klammern werden nur überschrieben, wenn sie automatisch eingefügt wurden.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Aktiviert horizontale Führungslinien als Ergänzung zu vertikalen Klammernpaarführungslinien.",
"editor.guides.highlightActiveBracketPair": "Steuert, ob der Editor das aktive Klammerpaar hervorheben soll.",
"editor.guides.highlightActiveIndentation": "Steuert, ob der Editor die aktive Einzugsführungslinie hevorheben soll.",
"editor.guides.highlightActiveIndentation.always": "Hebt die aktive Einzugshilfslinie hervor, selbst wenn Klammerhilfslinien hervorgehoben sind.",
"editor.guides.highlightActiveIndentation.false": "Heben Sie die aktive Einzugshilfslinie nicht hervor.",
"editor.guides.highlightActiveIndentation.true": "Hebt die aktive Einzugsführung hervor.",
"editor.guides.indentation": "Steuert, ob der Editor Einzugsführungslinien rendern soll.",
"editor.inlayHints.off": "Inlay-Hinweise sind deaktiviert",
"editor.inlayHints.offUnlessPressed": "Inlayhinweise sind standardmäßig ausgeblendet. Sie werden angezeigt, wenn {0} gedrückt gehalten wird.",
"editor.inlayHints.on": "Inlay-Hinweise sind aktiviert",
"editor.inlayHints.onUnlessPressed": "Inlay-Hinweise werden standardmäßig angezeigt und ausgeblendet, wenn Sie {0} gedrückt halten",
"editor.stickyScroll": "Zeigt die geschachtelten aktuellen Bereiche während des Bildlaufs am oberen Rand des Editors an.",
"editor.stickyScroll.": "Definiert die maximale Anzahl fixierter Linien, die angezeigt werden sollen.",
"editor.suggest.matchOnWordStartOnly": "Wenn dies aktiviert ist, erfordert die IntelliSense-Filterung, dass das erste Zeichen mit einem Wortanfang übereinstimmt, z. B. „c“ in „Console“ oder „WebContext“, aber _nicht_ bei „description“. Wenn diese Option deaktiviert ist, zeigt IntelliSense mehr Ergebnisse an, sortiert sie aber weiterhin nach der Übereinstimmungsqualität.",
"editor.suggest.showClasss": "Wenn aktiviert, zeigt IntelliSense \"class\"-Vorschläge an.",
"editor.suggest.showColors": "Wenn aktiviert, zeigt IntelliSense \"color\"-Vorschläge an.",
"editor.suggest.showConstants": "Wenn aktiviert, zeigt IntelliSense \"constant\"-Vorschläge an.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Wenn aktiviert, zeigt IntelliSense \"variable\"-Vorschläge an.",
"editorViewAccessibleLabel": "Editor-Inhalt",
"emptySelectionClipboard": "Steuert, ob ein Kopiervorgang ohne Auswahl die aktuelle Zeile kopiert.",
"experimentalWhitespaceRendering": "Steuert, ob Leerzeichen mit einer neuen experimentellen Methode gerendert werden.",
"experimentalWhitespaceRendering.font": "Verwenden Sie eine neue Rendering-Methode mit Schriftartzeichen.",
"experimentalWhitespaceRendering.off": "Verwenden Sie die stabile Rendering-Methode.",
"experimentalWhitespaceRendering.svg": "Verwenden Sie eine neue Rendering-Methode mit SVGs.",
"fastScrollSensitivity": "Multiplikator für Scrollgeschwindigkeit bei Drücken von ALT.",
"find.addExtraSpaceOnTop": "Steuert, ob das Suchwidget zusätzliche Zeilen im oberen Bereich des Editors hinzufügen soll. Wenn die Option auf \"true\" festgelegt ist, können Sie über die erste Zeile hinaus scrollen, wenn das Suchwidget angezeigt wird.",
"find.autoFindInSelection": "Steuert die Bedingung zum automatischen Aktivieren von \"In Auswahl suchen\".",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Hiermit werden Schriftligaturen (Schriftartfeatures \"calt\" und \"liga\") aktiviert/deaktiviert. Ändern Sie diesen Wert in eine Zeichenfolge, um die CSS-Eigenschaft \"font-feature-settings\" detailliert zu steuern.",
"fontLigaturesGeneral": "Hiermit werden Schriftligaturen oder Schriftartfeatures konfiguriert. Hierbei kann es sich entweder um einen booleschen Wert zum Aktivieren oder Deaktivieren von Ligaturen oder um eine Zeichenfolge für den Wert der CSS-Eigenschaft \"font-feature-settings\" handeln.",
"fontSize": "Legt die Schriftgröße in Pixeln fest.",
"fontVariationSettings": "Explizite CSS-Eigenschaft „font-variation-settings“. Stattdessen kann ein boolescher Wert eingeben werden, wenn nur „font-weight“ in „font-variation-settings“ übersetzt werden muss.",
"fontVariations": "Aktiviert/deaktiviert die Übersetzung von „font-weight“ in „font-variation-settings“. Ändern Sie dies in eine Zeichenfolge für eine differenzierte Steuerung der CSS-Eigenschaft „font-variation-settings“.",
"fontVariationsGeneral": "Konfiguriert Variationen der Schriftart. Kann entweder ein boolescher Wert zum Aktivieren/Deaktivieren der Übersetzung von „font-weight“ in „font-variation-settings“ oder eine Zeichenfolge für den Wert der CSS-Eigenschaft „font-variation-settings“ sein.",
"fontWeight": "Steuert die Schriftbreite. Akzeptiert die Schlüsselwörter \"normal\" und \"bold\" sowie Zahlen zwischen 1 und 1000.",
"fontWeightErrorMessage": "Es sind nur die Schlüsselwörter \"normal\" und \"bold\" sowie Zahlen zwischen 1 und 1000 zulässig.",
"formatOnPaste": "Steuert, ob der Editor den eingefügten Inhalt automatisch formatieren soll. Es muss ein Formatierer vorhanden sein, der in der Lage ist, auch Dokumentbereiche zu formatieren.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Steuert, ob die Hovermarkierung angezeigt wird.",
"hover.sticky": "Steuert, ob die Hovermarkierung sichtbar bleiben soll, wenn der Mauszeiger darüber bewegt wird.",
"inlayHints.enable": "Aktiviert die Inlay-Hinweise im Editor.",
"inlayHints.fontFamily": "Steuert die Schriftfamilie für Inlay-Hinweise im Editor. Wenn der Wert „leer“ festgelegt wird, wird die „#editor.fontFamily#“ verwendet.",
"inlayHints.fontSize": "Steuert den Schriftgrad von Inlayhinweisen im Editor. Ein Standardwert von 90 % der \"#editor.fontSize#\" wird verwendet, wenn der konfigurierte Wert kleiner als „5“ oder größer als der Schriftgrad des Editors ist.",
"inlayHints.fontFamily": "Steuert die Schriftartfamilie von Einlapphinweisen im Editor. Bei Festlegung auf \"leer\" wird die {0} verwendet.",
"inlayHints.fontSize": "Steuert den Schriftgrad von Einlapphinweisen im Editor. Standardmäßig wird die {0} verwendet, wenn der konfigurierte Wert kleiner als {1} oder größer als der Schriftgrad des Editors ist.",
"inlayHints.padding": "Aktiviert den Abstand um die Inlay-Hinweise im Editor.",
"inline": "Schnelle Vorschläge werden als inaktiver Text angezeigt",
"inlineSuggest.enabled": "Steuert, ob Inline-Vorschläge automatisch im Editor angezeigt werden.",
"inlineSuggest.showToolbar": "Steuert, wann die Inlinevorschlagssymbolleiste angezeigt werden soll.",
"inlineSuggest.showToolbar.always": "Die Symbolleiste „Inline-Vorschlag“ anzeigen, wenn ein Inline-Vorschlag angezeigt wird.",
"inlineSuggest.showToolbar.onHover": "Die Symbolleiste „Inline-Vorschlag“ anzeigen, wenn Sie mit dem Mauszeiger auf einen Inline-Vorschlag zeigen.",
"letterSpacing": "Legt den Abstand der Buchstaben in Pixeln fest.",
"lineHeight": "Steuert die Zeilenhöhe. \r\n – Verwenden Sie 0, um die Zeilenhöhe automatisch anhand des Schriftgrads zu berechnen.\r\n – Werte zwischen 0 und 8 werden als Multiplikator mit dem Schriftgrad verwendet.\r\n – Werte größer oder gleich 8 werden als effektive Werte verwendet.",
"lineNumbers": "Steuert die Anzeige von Zeilennummern.",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "Steuert, ob die verknüpfte Bearbeitung im Editor aktiviert ist. Abhängig von der Sprache werden zugehörige Symbole, z. B. HTML-Tags, während der Bearbeitung aktualisiert.",
"links": "Steuert, ob der Editor Links erkennen und anklickbar machen soll.",
"matchBrackets": "Passende Klammern hervorheben",
"minimap.autohide": "Steuert, ob die Minimap automatisch ausgeblendet wird.",
"minimap.enabled": "Steuert, ob die Minimap angezeigt wird.",
"minimap.maxColumn": "Begrenzen Sie die Breite der Minimap, um nur eine bestimmte Anzahl von Spalten zu rendern.",
"minimap.renderCharacters": "Die tatsächlichen Zeichen in einer Zeile rendern im Gegensatz zu Farbblöcken.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "Die Minimap hat die gleiche Größe wie der Editor-Inhalt (und kann scrollen).",
"mouseWheelScrollSensitivity": "Ein Multiplikator, der für die Mausrad-Bildlaufereignisse \"deltaX\" und \"deltaY\" verwendet werden soll.",
"mouseWheelZoom": "Schriftart des Editors vergrößern, wenn das Mausrad verwendet und die STRG-TASTE gedrückt wird.",
"multiCursorLimit": "Steuert die maximale Anzahl von Cursorn, die sich gleichzeitig in einem aktiven Editor befindet.",
"multiCursorMergeOverlapping": "Mehrere Cursor zusammenführen, wenn sie sich überlappen.",
"multiCursorModifier": "Der Modifizierer, der zum Hinzufügen mehrerer Cursor mit der Maus verwendet wird. Die Mausbewegungen \"Gehe zu Definition\" und \"Link öffnen\" werden so angepasst, dass kein Konflikt mit dem Multi-Cursor-Modifizierer entsteht. [Weitere Informationen](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "Der Modifizierer, der zum Hinzufügen mehrerer Cursor mit der Maus verwendet werden soll. Die Mausgesten \"Gehe zu Definition\" und \"Link öffnen\" werden so angepasst, dass sie nicht mit dem [Multicursormodifizierer](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-Modifizierer) in Konflikt stehen.",
"multiCursorModifier.alt": "Ist unter Windows und Linux der ALT-Taste und unter macOS der Wahltaste zugeordnet.",
"multiCursorModifier.ctrlCmd": "Ist unter Windows und Linux der STRG-Taste und unter macOS der Befehlstaste zugeordnet.",
"multiCursorPaste": "Steuert das Einfügen, wenn die Zeilenanzahl des Einfügetexts der Cursor-Anzahl entspricht.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Steuert, ob der Inline-Editor oder die Struktur im Peek-Widget fokussiert werden soll.",
"peekWidgetDefaultFocus.editor": "Editor fokussieren, wenn Sie den Peek-Editor öffnen",
"peekWidgetDefaultFocus.tree": "Struktur beim Öffnen des Peek-Editors fokussieren",
"quickSuggestions": "Steuert, ob Vorschläge automatisch während der Eingabe angezeigt werden sollen.",
"quickSuggestions": "Steuert, ob Vorschläge während des Tippens automatisch angezeigt werden sollen. Dies kann bei der Eingabe von Kommentaren, Zeichenketten und anderem Code kontrolliert werden. Schnellvorschläge können so konfiguriert werden, dass sie als Geistertext oder mit dem Vorschlags-Widget angezeigt werden. Beachten Sie auch die '{0}'-Einstellung, die steuert, ob Vorschläge durch Sonderzeichen ausgelöst werden.",
"quickSuggestions.comments": "Schnellvorschläge innerhalb von Kommentaren aktivieren.",
"quickSuggestions.other": "Schnellvorschläge außerhalb von Zeichenfolgen und Kommentaren aktivieren.",
"quickSuggestions.strings": "Schnellvorschläge innerhalb von Zeichenfolgen aktivieren.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Steuert, wann die Steuerungselemente für die Codefaltung am Bundsteg angezeigt werden.",
"showFoldingControls.always": "Steuerelemente für die Codefaltung immer anzeigen.",
"showFoldingControls.mouseover": "Steuerelemente für die Codefaltung nur anzeigen, wenn sich die Maus über dem Bundsteg befindet.",
"showFoldingControls.never": "Zeigen Sie niemals die Faltungssteuerelemente an, und verringern Sie die Größe des Bundstegs.",
"showUnused": "Steuert das Ausblenden von nicht verwendetem Code.",
"smoothScrolling": "Legt fest, ob der Editor Bildläufe animiert ausführt.",
"snippetSuggestions": "Steuert, ob Codeschnipsel mit anderen Vorschlägen angezeigt und wie diese sortiert werden.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Emuliert das Auswahlverhalten von Tabstoppzeichen, wenn Leerzeichen für den Einzug verwendet werden. Die Auswahl wird an Tabstopps ausgerichtet.",
"suggest.filterGraceful": "Steuert, ob Filter- und Suchvorschläge geringfügige Tippfehler berücksichtigen.",
"suggest.insertMode": "Legt fest, ob Wörter beim Akzeptieren von Vervollständigungen überschrieben werden. Beachten Sie, dass dies von Erweiterungen abhängt, die für dieses Features aktiviert sind.",
"suggest.insertMode.always": "Wählen Sie immer einen Vorschlag aus, wenn IntelliSense automatisch ausgelöst wird.",
"suggest.insertMode.insert": "Vorschlag einfügen, ohne den Text auf der rechten Seite des Cursors zu überschreiben",
"suggest.insertMode.never": "Wählen Sie niemals einen Vorschlag aus, wenn IntelliSense automatisch ausgelöst wird.",
"suggest.insertMode.replace": "Vorschlag einfügen und Text auf der rechten Seite des Cursors überschreiben",
"suggest.insertMode.whenQuickSuggestion": "Wählen Sie einen Vorschlag nur aus, wenn Sie IntelliSense während der Eingabe auslösen.",
"suggest.insertMode.whenTriggerCharacter": "Wählen Sie einen Vorschlag nur aus, wenn IntelliSense aus einem Triggerzeichen ausgelöst wird.",
"suggest.localityBonus": "Steuert, ob bei der Sortierung Wörter priorisiert werden, die in der Nähe des Cursors stehen.",
"suggest.maxVisibleSuggestions.dep": "Diese Einstellung ist veraltet. Die Größe des Vorschlagswidgets kann jetzt geändert werden.",
"suggest.preview": "Steuert, ob das Ergebnis des Vorschlags im Editor in der Vorschau angezeigt werden soll.",
"suggest.selectionMode": "Steuert, ob ein Vorschlag ausgewählt wird, wenn das Widget angezeigt wird. Beachten Sie, dass dies nur für automatisch ausgelöste Vorschläge gilt (\"#editor.quickSuggestions#\" und \"#editor.suggestOnTriggerCharacters#\"), und dass ein Vorschlag immer ausgewählt wird, wenn er explizit aufgerufen wird, z. B. über STRG+LEERTASTE.",
"suggest.shareSuggestSelections": "Steuert, ob gespeicherte Vorschlagauswahlen in verschiedenen Arbeitsbereichen und Fenstern gemeinsam verwendet werden (dafür ist \"#editor.suggestSelection#\" erforderlich).",
"suggest.showIcons": "Steuert, ob Symbole in Vorschlägen ein- oder ausgeblendet werden.",
"suggest.showInlineDetails": "Steuert, ob Vorschlagsdetails inline mit der Bezeichnung oder nur im Detailwidget angezeigt werden.",
"suggest.showStatusBar": "Steuert die Sichtbarkeit der Statusleiste unten im Vorschlagswidget.",
"suggest.snippetsPreventQuickSuggestions": "Steuert, ob ein aktiver Schnipsel verhindert, dass der Bereich \"Schnelle Vorschläge\" angezeigt wird.",
"suggestFontSize": "Schriftgröße für das vorgeschlagene Widget. Bei Festlegung auf 0 wird der Wert von \"#editor.fontSize#\" verwendet.",
"suggestLineHeight": "Zeilenhöhe für das vorgeschlagene Widget. Bei Festlegung auf 0 wird der Wert von \"#editor.lineHeight#\" verwendet. Der Mindestwert ist 8.",
"suggestFontSize": "Schriftgrad für das Vorschlagswidget. Bei Festlegung auf {0} wird der Wert von {1} verwendet.",
"suggestLineHeight": "Linienhöhe für das Vorschlagswidget. Bei Festlegung auf {0} wird der Wert von {1} verwendet. Der Mindestwert ist 8.",
"suggestOnTriggerCharacters": "Steuert, ob Vorschläge automatisch angezeigt werden sollen, wenn Triggerzeichen eingegeben werden.",
"suggestSelection": "Steuert, wie Vorschläge bei Anzeige der Vorschlagsliste vorab ausgewählt werden.",
"suggestSelection.first": "Immer den ersten Vorschlag auswählen.",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Tab-Vervollständigungen deaktivieren.",
"tabCompletion.on": "Die Tab-Vervollständigung fügt den passendsten Vorschlag ein, wenn auf Tab gedrückt wird.",
"tabCompletion.onlySnippets": "Codeschnipsel per Tab vervollständigen, wenn die Präfixe übereinstimmen. Funktioniert am besten, wenn \"quickSuggestions\" deaktiviert sind.",
"tabFocusMode": "Steuert, ob der Editor Registerkarten empfängt oder zur Navigation zur Workbench zurückgibt.",
"unfoldOnClickAfterEndOfLine": "Steuert, ob eine Zeile aufgefaltet wird, wenn nach einer gefalteten Zeile auf den leeren Inhalt geklickt wird.",
"unicodeHighlight.allowedCharacters": "Definiert zulässige Zeichen, die nicht hervorgehoben werden.",
"unicodeHighlight.allowedLocales": "Unicodezeichen, die in zulässigen Gebietsschemas üblich sind, werden nicht hervorgehoben.",
"unicodeHighlight.ambiguousCharacters": "Legt fest, ob Zeichen hervorgehoben werden, die mit einfachen ASCII-Zeichen verwechselt werden können, mit Ausnahme derjenigen, die im aktuellen Gebietsschema des Benutzers üblich sind.",
"unicodeHighlight.includeComments": "Legt fest, ob Zeichen in Kommentaren auch mit Unicode-Hervorhebung versehen werden sollen.",
"unicodeHighlight.includeStrings": "Legt fest, ob Zeichen in Zeichenfolgen auch mit Unicode-Hervorhebung versehen werden sollen.",
"unicodeHighlight.includeComments": "Steuert, ob Zeichen in Kommentaren auch mit Unicode-Hervorhebung versehen werden sollen.",
"unicodeHighlight.includeStrings": "Steuert, ob Zeichen in Zeichenfolgen auch mit Unicode-Hervorhebung versehen werden sollen.",
"unicodeHighlight.invisibleCharacters": "Legt fest, ob Zeichen, die nur als Platzhalter dienen oder überhaupt keine Breite haben, hervorgehoben werden.",
"unicodeHighlight.nonBasicASCII": "Legt fest, ob alle nicht einfachen ASCII-Zeichen hervorgehoben werden. Nur Zeichen zwischen U+0020 und U+007E, Tabulator, Zeilenvorschub und Wagenrücklauf gelten als einfache ASCII-Zeichen.",
"unusualLineTerminators": "Entfernen Sie unübliche Zeilenabschlusszeichen, die Probleme verursachen können.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Ungewöhnliche Zeilenabschlusszeichen werden ignoriert.",
"unusualLineTerminators.prompt": "Zum Entfernen ungewöhnlicher Zeilenabschlusszeichen wird eine Eingabeaufforderung angezeigt.",
"useTabStops": "Das Einfügen und Löschen von Leerzeichen erfolgt nach Tabstopps.",
"wordBreak": "Steuert die Regeln für Trennstellen, die für Texte in Chinesisch/Japanisch/Koreanisch (CJK) verwendet werden.",
"wordBreak.keepAll": "Trennstellen dürfen nicht für Texte in Chinesisch/Japanisch/Koreanisch (CJK) verwendet werden. Das Verhalten von Nicht-CJK-Texten ist mit dem für normales Verhalten identisch.",
"wordBreak.normal": "Verwenden Sie die Standardregel für Zeilenumbrüche.",
"wordSeparators": "Zeichen, die als Worttrennzeichen verwendet werden, wenn wortbezogene Navigationen oder Vorgänge ausgeführt werden.",
"wordWrap": "Steuert, wie der Zeilenumbruch durchgeführt werden soll.",
"wordWrap.bounded": "Der Zeilenumbruch erfolgt beim Mindestanzeigebereich und \"#editor.wordWrapColumn\".",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "Umbrochene Zeilen erhalten + 1 Einzug auf das übergeordnete Element.",
"wrappingIndent.none": "Kein Einzug. Umbrochene Zeilen beginnen bei Spalte 1.",
"wrappingIndent.same": "Umbrochene Zeilen erhalten den gleichen Einzug wie das übergeordnete Element.",
"wrappingStrategy": "Steuert den Algorithmus, der Umbruchpunkte berechnet.",
"wrappingStrategy": "Steuert den Algorithmus, der Umbruchpunkte berechnet. Beachten Sie, dass \"advanced\" im Barrierefreiheitsmodus für eine optimale Benutzererfahrung verwendet wird.",
"wrappingStrategy.advanced": "Delegiert die Berechnung von Umbruchpunkten an den Browser. Dies ist ein langsamer Algorithmus, der bei großen Dateien Code Freezes verursachen kann, aber in allen Fällen korrekt funktioniert.",
"wrappingStrategy.simple": "Es wird angenommen, dass alle Zeichen gleich breit sind. Dies ist ein schneller Algorithmus, der für Festbreitenschriftarten und bestimmte Alphabete (wie dem lateinischen), bei denen die Glyphen gleich breit sind, korrekt funktioniert."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Hintergrundfarbe der inaktiven Klammerpaar-Hilfslinien (6). Erfordert das Aktivieren von Klammerpaar-Hilfslinien.",
"editorCodeLensForeground": "Vordergrundfarbe der CodeLens-Links im Editor",
"editorCursorBackground": "Hintergrundfarbe vom Editor-Cursor. Erlaubt die Anpassung der Farbe von einem Zeichen, welches von einem Block-Cursor überdeckt wird.",
"editorDimmedLineNumber": "Die Farbe der letzten Editor-Zeile, wenn „editor.renderFinalNewline“ auf „abgeblendet“ festgelegt ist.",
"editorGhostTextBackground": "Hintergrundfarbe des Ghost-Texts im Editor.",
"editorGhostTextBorder": "Rahmenfarbe des Ghost-Texts im Editor.",
"editorGhostTextForeground": "Vordergrundfarbe des Ghost-Texts im Editor.",
"editorGutter": "Hintergrundfarbe der Editorleiste. Die Leiste enthält die Glyphenränder und die Zeilennummern.",
"editorIndentGuides": "Farbe der Führungslinien für Einzüge im Editor.",
"editorLineNumbers": "Zeilennummernfarbe im Editor.",
"editorOverviewRulerBackground": "Hintergrundfarbe des Übersichtslineals im Editor. Wird nur verwendet, wenn die Minimap aktiviert ist und auf der rechten Seite des Editors platziert wird.",
"editorOverviewRulerBackground": "Hintergrundfarbe des Editor-Übersichtslineals.",
"editorOverviewRulerBorder": "Farbe des Rahmens für das Übersicht-Lineal.",
"editorRuler": "Farbe des Editor-Lineals.",
"editorUnicodeHighlight.background": "Hintergrundfarbe, die zum Hervorheben von Unicode-Zeichen verwendet wird.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Durch Drücken der TAB-TASTE im aktuellen Editor wird der Fokus in das nächste Element verschoben, das den Fokus erhalten kann. Der {0}-Befehl kann zurzeit nicht durch eine Tastenzuordnung ausgelöst werden.",
"toggleHighContrast": "Zu Design mit hohem Kontrast umschalten"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} Zeichen",
"showMore": "Mehr anzeigen ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Anker festgelegt bei \"{0}:{1}\"",
"cancelSelectionAnchor": "Auswahlanker abbrechen",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Kopieren als",
"miCopy": "&&Kopieren",
"miCut": "&&Ausschneiden",
"miPaste": "&&Einfügen"
"miPaste": "&&Einfügen",
"share": "Freigeben"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Beim Anwenden der Code-Aktion ist ein unbekannter Fehler aufgetreten"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Beim Anwenden der Code-Aktion ist ein unbekannter Fehler aufgetreten",
"args.schema.apply": "Legt fest, wann die zurückgegebenen Aktionen angewendet werden",
"args.schema.apply.first": "Die erste zurückgegebene Codeaktion immer anwenden",
"args.schema.apply.ifSingle": "Die erste zurückgegebene Codeaktion anwenden, wenn nur eine vorhanden ist",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Importe organisieren",
"quickfix.trigger.label": "Schnelle Problembehebung ...",
"refactor.label": "Refactoring durchführen...",
"refactor.preview.label": "Mit Vorschau umgestalten...",
"source.label": "Quellaktion..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Aktivieren/Deaktivieren Sie die Anzeige von Gruppenheadern im Codeaktionsmenü."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Erneut generieren...",
"codeAction.widget.id.extract": "Extrahieren...",
"codeAction.widget.id.inline": "Inline...",
"codeAction.widget.id.more": "Weitere Aktionen...",
"codeAction.widget.id.move": "Verschieben...",
"codeAction.widget.id.quickfix": "Schnelle Problembehebung...",
"codeAction.widget.id.source": "Quellaktion...",
"codeAction.widget.id.surround": "Umgeben mit..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Deaktivierte Elemente ausblenden",
"showMoreActions": "Deaktivierte Elemente anzeigen"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Codeaktionen anzeigen",
"codeActionWithKb": "Codeaktionen anzeigen ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "Zeilenkommen&&tar umschalten"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Editor-Kontextmenü anzeigen"
"action.showContextMenu.label": "Editor-Kontextmenü anzeigen",
"context.minimap.minimap": "Minimap",
"context.minimap.renderCharacters": "Zeichen rendern",
"context.minimap.size": "Vertikale Größe",
"context.minimap.size.fill": "Ausfüllen",
"context.minimap.size.fit": "Anpassen",
"context.minimap.size.proportional": "Proportional",
"context.minimap.slider": "Schieberegler",
"context.minimap.slider.always": "Immer",
"context.minimap.slider.mouseover": "Maus über"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Aktivieren/Deaktivieren der Ausführung von Bearbeitungen von Erweiterungen beim Einfügen."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Einfügehandler werden ausgeführt..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Wiederholen mit Cursor",
"cursor.undo": "Mit Cursor rückgängig machen"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Drophandler werden ausgeführt..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Gibt an, ob der Editor einen abbrechbaren Vorgang ausführt, z. B. \"Verweisvorschau\"."
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Überschreibt das Flag „Math Case“.\r\nDas Flag wird für die Zukunft nicht gespeichert.\r\n0: Nichts unternehmen\r\n1: TRUE\r\n2: FALSE",
"actions.find.preserveCaseOverride": "Überschreibt das Flag „Preserve Case“.\r\nDas Flag wird für die Zukunft nicht gespeichert.\r\n0: Nichts unternehmen\r\n1: TRUE\r\n2: FALSE",
"actions.find.wholeWordOverride": "Überschreibt das Flag „Match Whole Word“.\r\nDas Flag wird für die Zukunft nicht gespeichert.\r\n0: Nichts unternehmen\r\n1: TRUE\r\n2: FALSE",
"findMatchAction.goToMatch": "Zu Übereinstimmung wechseln ...",
"findMatchAction.inputPlaceHolder": "Geben Sie eine Zahl ein, um zu einer bestimmten Übereinstimmung zu wechseln (zwischen 1 und {0}).",
"findMatchAction.inputValidationMessage": "Zahl zwischen 1 und {0} eingeben",
"findNextMatchAction": "Weitersuchen",
"findPreviousMatchAction": "Vorheriges Element suchen",
"miFind": "&&Suchen",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Nur die ersten {0} Ergebnisse wurden hervorgehoben, aber alle Suchoperationen werden auf dem gesamten Text durchgeführt."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Farbe des Faltsteuerelements im Editor-Bundsteg.",
"createManualFoldRange.label": "Faltungsbereich aus Auswahl erstellen",
"foldAction.label": "Falten",
"foldAllAction.label": "Alle falten",
"foldAllBlockComments.label": "Alle Blockkommentare falten",
"foldAllExcept.label": "Alle Regionen mit Ausnahme der ausgewählten zuklappen",
"foldAllMarkerRegions.label": "Alle Regionen falten",
"foldBackgroundBackground": "Hintergrundfarbe hinter gefalteten Bereichen. Die Farbe darf nicht deckend sein, sodass zugrunde liegende Dekorationen nicht ausgeblendet werden.",
"foldLevelAction.label": "Faltebene {0}",
"foldRecursivelyAction.label": "Rekursiv falten",
"gotoNextFold.label": "Zum nächsten Faltbereich wechseln",
"gotoParentFold.label": "Zur übergeordneten Reduzierung wechseln",
"gotoPreviousFold.label": "Zum vorherigen Faltbereich wechseln",
"maximum fold ranges": "Die Anzahl der faltbaren Regionen ist auf maximal {0} beschränkt. Erhöhen Sie die Konfigurationsoption [“Maximale faltbare Regionen“](command:workbench.action.openSettings?[“editor.foldingMaximumRegions“]) um weitere zu ermöglichen.",
"removeManualFoldingRanges.label": "Manuelle Faltbereiche entfernen",
"toggleFoldAction.label": "Einklappung umschalten",
"unFoldRecursivelyAction.label": "Faltung rekursiv aufheben",
"unfoldAction.label": "Auffalten",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Alle Regionen auffalten"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Farbe des Faltsteuerelements im Editor-Bundsteg.",
"foldBackgroundBackground": "Hintergrundfarbe hinter gefalteten Bereichen. Die Farbe darf nicht deckend sein, sodass zugrunde liegende Dekorationen nicht ausgeblendet werden.",
"foldingCollapsedIcon": "Symbol für zugeklappte Bereiche im Editor-Glyphenrand.",
"foldingExpandedIcon": "Symbol für aufgeklappte Bereiche im Editor-Glyphenrand."
"foldingExpandedIcon": "Symbol für aufgeklappte Bereiche im Editor-Glyphenrand.",
"foldingManualCollapedIcon": "Symbol für manuell reduzierte Bereiche im Glyphenrand des Editors.",
"foldingManualExpandedIcon": "Symbol für manuell erweiterte Bereiche im Glyphenrand des Editors."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Editorschriftart vergrößern",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Wird geladen...",
"stopped rendering": "Das Rendering langer Zeilen wurde aus Leistungsgründen angehalten. Dies kann über „editor.stopRenderingLineAfter“ konfiguriert werden.",
"too many characters": "Die Tokenisierung wird bei langen Zeilen aus Leistungsgründen übersprungen. Dies kann über „editor.maxTokenizationLineLength“ konfiguriert werden."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Problem anzeigen"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Anzeigegröße der Registerkarte ändern",
"configuredTabSize": "Konfigurierte Tabulatorgröße",
"currentTabSize": "Aktuelle Registerkartengröße",
"defaultTabSize": "Standardregisterkartengröße",
"detectIndentation": "Einzug aus Inhalt erkennen",
"editor.reindentlines": "Neuen Einzug für Zeilen festlegen",
"editor.reindentselectedlines": "Gewählte Zeilen zurückziehen",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "BEFEHL + Klicken"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Annehmen",
"acceptWord": "Wort annehmen",
"action.inlineSuggest.accept": "Inline-Vorschlag annehmen",
"action.inlineSuggest.acceptNextWord": "Nächstes Wort des Inline-Vorschlags annehmen",
"action.inlineSuggest.alwaysShowToolbar": "Symbolleiste immer anzeigen",
"action.inlineSuggest.hide": "Inlinevorschlag ausblenden",
"action.inlineSuggest.showNext": "Nächsten Inline-Vorschlag anzeigen",
"action.inlineSuggest.showPrevious": "Vorherigen Inline-Vorschlag anzeigen",
"action.inlineSuggest.trigger": "Inline-Vorschlag auslösen",
"action.inlineSuggest.undo": "\"Wort annehmen\" rückgängig machen",
"alwaysShowInlineSuggestionToolbar": "Gibt an, ob die Symbolleiste „Inline-Vorschlag“ immer sichtbar sein soll.",
"canUndoInlineSuggestion": "Gibt an, ob ein Inlinevorschlag rückgängig machen würde.",
"inlineSuggestionHasIndentation": "Gibt an, ob der Inline-Vorschlag mit Leerzeichen beginnt.",
"inlineSuggestionHasIndentationLessThanTabSize": "Ob der Inline-Vorschlag mit Leerzeichen beginnt, das kleiner ist als das, was durch die Tabulatortaste eingefügt werden würde",
"inlineSuggestionVisible": "Gibt an, ob ein Inline-Vorschlag sichtbar ist."
"inlineSuggestionVisible": "Gibt an, ob ein Inline-Vorschlag sichtbar ist.",
"undoAcceptWord": "\"Wort annehmen\" rückgängig machen"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Vorschlag:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Weiter",
"parameterHintsNextIcon": "Symbol für die Anzeige des nächsten Parameterhinweises.",
"parameterHintsPreviousIcon": "Symbol für die Anzeige des vorherigen Parameterhinweises.",
"previous": "Zurück"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Durch nächsten Wert ersetzen",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Auswahl duplizieren",
"editor.transformToCamelcase": "In Camel-Fall transformieren",
"editor.transformToKebabcase": "Verwandle dich in eine Kebab-Hülle",
"editor.transformToLowercase": "In Kleinbuchstaben umwandeln",
"editor.transformToSnakecase": "In Snake Case umwandeln",
"editor.transformToTitlecase": "In große Anfangsbuchstaben umwandeln",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Führen Sie den Befehl \"{0}\" aus."
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Ein Bearbeiten ist im schreibgeschützten Editor nicht möglich",
"messageVisible": "Gibt an, ob der Editor zurzeit eine Inlinenachricht anzeigt."
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Letzte Auswahl in vorherige Übereinstimmungssuche verschieben",
"mutlicursor.addCursorsToBottom": "Cursor am Ende hinzufügen",
"mutlicursor.addCursorsToTop": "Cursor am Anfang hinzufügen",
"mutlicursor.focusNextCursor": "Fokus auf nächsten Cursor",
"mutlicursor.focusNextCursor.description": "Fokussiert den nächsten Cursor",
"mutlicursor.focusPreviousCursor": "Fokus auf vorherigen Cursor",
"mutlicursor.focusPreviousCursor.description": "Fokussiert den vorherigen Cursor",
"mutlicursor.insertAbove": "Cursor oberhalb hinzufügen",
"mutlicursor.insertAtEndOfEachLineSelected": "Cursor an Zeilenenden hinzufügen",
"mutlicursor.insertBelow": "Cursor unterhalb hinzufügen",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Hintergrundfarbe der Leiste im Peek-Editor.",
"peekViewEditorMatchHighlight": "Farbe für Übereinstimmungsmarkierungen im Peek-Editor.",
"peekViewEditorMatchHighlightBorder": "Rahmen für Übereinstimmungsmarkierungen im Peek-Editor.",
"peekViewEditorStickScrollBackground": "Die Hintergrundfarbe für den „Sticky“-Bildlaufeffekt im Editor für die „Peek“-Ansicht.",
"peekViewResultsBackground": "Hintergrundfarbe der Ergebnisliste in der Peek-Ansicht.",
"peekViewResultsFileForeground": "Vordergrundfarbe für Dateiknoten in der Ergebnisliste der Peek-Ansicht.",
"peekViewResultsMatchForeground": "Vordergrundfarbe für Zeilenknoten in der Ergebnisliste der Peek-Ansicht.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "Typparameter ({0})",
"variable": "Variablen ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Ein Bearbeiten ist im schreibgeschützten Editor nicht möglich",
"editor.simple.readonly": "Bearbeitung von schreibgeschützter Eingabe nicht möglich"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "\"{0}\" erfolgreich in \"{1}\" umbenannt. Zusammenfassung: {2}",
"enablePreview": "Möglichkeit aktivieren/deaktivieren, Änderungen vor dem Umbenennen als Vorschau anzeigen zu lassen",
"label": "\"{0}\" wird umbenannt.",
"label": "'{0}' wird in '{1}' umbenannt",
"no result": "Kein Ergebnis.",
"quotableLabel": "{0} wird umbenannt.",
"quotableLabel": "{0} wird in {1} umbenannt.",
"rename.failed": "Die rename-Funktion konnte die Änderungen nicht berechnen.",
"rename.failedApply": "Die rename-Funktion konnte die Änderungen nicht anwenden.",
"rename.label": "Symbol umbenennen",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Gibt an, ob ein nächster Tabstopp im Schnipselmodus vorhanden ist.",
"hasPrevTabstop": "Gibt an, ob ein vorheriger Tabstopp im Schnipselmodus vorhanden ist.",
"inSnippetMode": "Gibt an, ob der Editor sich zurzeit im Schnipselmodus befindet."
"inSnippetMode": "Gibt an, ob der Editor sich zurzeit im Schnipselmodus befindet.",
"next": "Zum nächsten Platzhalter wechseln..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "April",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Mittwoch",
"WednesdayShort": "Mi"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Fixierter Bildlauf",
"mitoggleStickyScroll": "Fixierten Bildlauf &&umschalten",
"stickyScroll": "Fixierter Bildlauf",
"toggleStickyScroll": "Fixierten Bildlauf umschalten"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Gibt an, ob Vorschläge durch Drücken der EINGABETASTE eingefügt werden.",
"suggestWidgetDetailsVisible": "Gibt an, ob Vorschlagsdetails sichtbar sind.",
"suggestWidgetHasSelection": "Gibt an, ob ein Vorschlag fokussiert ist",
"suggestWidgetMultipleSuggestions": "Gibt an, ob mehrere Vorschläge zur Auswahl stehen.",
"suggestionCanResolve": "Gibt an, ob der aktuelle Vorschlag die Auflösung weiterer Details unterstützt.",
"suggestionHasInsertAndReplaceRange": "Gibt an, ob der aktuelle Vorschlag Verhalten zum Einfügen und Ersetzen aufweist.",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Symbol für weitere Informationen im Vorschlags-Widget."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Die Vordergrundfarbe für Arraysymbole. Diese Symbole werden in den Widgets für Gliederung, Breadcrumbs und Vorschläge angezeigt.",
@ -1209,33 +1360,87 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "Die Datei \"{0}\" enthält mindestens ein ungewöhnliches Zeilenabschlusszeichen, z. B. Zeilentrennzeichen (LS) oder Absatztrennzeichen (PS).\r\n\r\nEs wird empfohlen, sie aus der Datei zu entfernen. Dies kann über \"editor.unusualLineTerminators\" konfiguriert werden.",
"unusualLineTerminators.fix": "Entfernen ungewöhnlicher Zeilenabschlusszeichen",
"unusualLineTerminators.fix": "&&Ungewöhnliche Zeilenabschlusszeichen entfernen",
"unusualLineTerminators.ignore": "Ignorieren",
"unusualLineTerminators.message": "Ungewöhnliche Zeilentrennzeichen erkannt",
"unusualLineTerminators.title": "Ungewöhnliche Zeilentrennzeichen"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Übersichtslinealmarkerfarbd für das Hervorheben von Symbolen. Die Farbe darf nicht deckend sein, weil sie sonst die zugrunde liegenden Dekorationen verdeckt.",
"overviewRulerWordHighlightStrongForeground": "Übersichtslinealmarkerfarbe für Symbolhervorhebungen bei Schreibzugriff. Die Farbe darf nicht deckend sein, weil sie sonst die zugrunde liegenden Dekorationen verdeckt.",
"overviewRulerWordHighlightTextForeground": "Die Markierungsfarbe des Übersichtslineals eines Textteils für ein Symbol. Die Farbe darf nicht deckend sein, um zugrunde liegende Dekorationen nicht auszublenden.",
"wordHighlight": "Hintergrundfarbe eines Symbols beim Lesezugriff, z.B. beim Lesen einer Variablen. Die Farbe darf nicht deckend sein, damit sie nicht die zugrunde liegenden Dekorationen verdeckt.",
"wordHighlight.next.label": "Gehe zur nächsten Symbolhervorhebungen",
"wordHighlight.previous.label": "Gehe zur vorherigen Symbolhervorhebungen",
"wordHighlight.trigger.label": "Symbol-Hervorhebung ein-/ausschalten",
"wordHighlightBorder": "Randfarbe eines Symbols beim Lesezugriff, wie etwa beim Lesen einer Variablen.",
"wordHighlightStrong": "Hintergrundfarbe eines Symbols bei Schreibzugriff, z.B. beim Schreiben in eine Variable. Die Farbe darf nicht deckend sein, weil sie sonst die zugrunde liegenden Dekorationen verdeckt.",
"wordHighlightStrongBorder": "Randfarbe eines Symbols beim Schreibzugriff, wie etwa beim Schreiben einer Variablen."
"wordHighlightStrongBorder": "Randfarbe eines Symbols beim Schreibzugriff, wie etwa beim Schreiben einer Variablen.",
"wordHighlightText": "Die Hintergrundfarbe eines Textteils für ein Symbol. Die Farbe darf nicht deckend sein, um zugrunde liegende Dekorationen nicht auszublenden.",
"wordHighlightTextBorder": "Die Rahmenfarbe eines Textteils für ein Symbol."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Gehe zur nächsten Symbolhervorhebungen",
"wordHighlight.previous.label": "Gehe zur vorherigen Symbolhervorhebungen",
"wordHighlight.trigger.label": "Symbol-Hervorhebung ein-/ausschalten"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Wort löschen"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Entwickler",
"help": "Hilfe",
"preferences": "Einstellungen",
"test": "Test",
"view": "Ansehen"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Ausblenden",
"resetThisMenu": "Menü zurücksetzen"
},
"vs/platform/actions/common/menuService": {
"hide.label": "\"{0}\" ausblenden"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Aktionswidget",
"customQuickFixWidget.labels": "{0} deaktiviert, Grund: {1}",
"label": "{0} zum Anwenden",
"label-preview": "{0} zum Anwenden, {1} für die Vorschau"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Ausgewählte Aktion akzeptieren",
"codeActionMenuVisible": "Gibt an, ob die Aktionswidgetliste sichtbar ist.",
"hideCodeActionWidget.title": "Codeaktionswidget ausblenden",
"previewSelected.title": "Vorschau für ausgewählte Elemente anzeigen",
"selectNextCodeAction.title": "Nächste Aktion auswählen",
"selectPrevCodeAction.title": "Vorherige Aktion auswählen"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Vergleichslinie gelöscht",
"audioCues.diffLineInserted": "Vergleichslinie eingefügt",
"audioCues.diffLineModified": "Vergleichslinie geändert",
"audioCues.lineHasBreakpoint.name": "Haltepunkt in der Zeile",
"audioCues.lineHasError.name": "Fehler in der Zeile",
"audioCues.lineHasFoldedArea.name": "Gefalteter Bereich in der Zeile",
"audioCues.lineHasInlineSuggestion.name": "Inlinevorschlag in der Zeile",
"audioCues.lineHasWarning.name": "Warnung in der Zeile",
"audioCues.noInlayHints": "Keine Inlay-Hinweise in der Zeile",
"audioCues.notebookCellCompleted": "Notebookzelle abgeschlossen",
"audioCues.notebookCellFailed": "Notebookzelle fehlgeschlagen",
"audioCues.onDebugBreak.name": "Debugger auf Haltepunkt beendet",
"audioCues.taskCompleted": "Aufgabe abgeschlossen",
"audioCues.taskFailed": "Aufgabe fehlgeschlagen",
"audioCues.terminalBell": "Terminalglocke",
"audioCues.terminalCommandFailed": "Terminalbefehl fehlgeschlagen",
"audioCues.terminalQuickFix.name": "Terminale schnelle Problembehebung"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "\"{0}\" kann nicht registriert werden. Die zugeordnete Richtlinie {1} ist bereits bei {2} registriert.",
"config.property.duplicate": "{0}\" kann nicht registriert werden. Diese Eigenschaft ist bereits registriert.",
"config.property.empty": "Eine leere Eigenschaft kann nicht registriert werden.",
"config.property.languageDefault": "\"{0}\" kann nicht registriert werden. Stimmt mit dem Eigenschaftsmuster \"\\\\[.*\\\\]$\" zum Beschreiben sprachspezifischer Editor-Einstellungen überein. Verwenden Sie den Beitrag \"configurationDefaults\".",
"defaultLanguageConfiguration.description": "Konfigurieren Sie Einstellungen, die für die \\\"{0}\\\" Sprache überschrieben werden sollen.",
"defaultLanguageConfiguration.description": "Konfigurieren Sie Einstellungen, die für die Sprache {0} überschrieben werden sollen.",
"defaultLanguageConfigurationOverrides.title": "Außerkraftsetzungen für die Standardsprachkonfiguration",
"overrideSettings.defaultDescription": "Zu überschreibende Editor-Einstellungen für eine Sprache konfigurieren.",
"overrideSettings.errorMessage": "Diese Einstellung unterstützt keine sprachspezifische Konfiguration."
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Gibt an, ob Linux als Betriebssystem verwendet wird.",
"isMac": "Gibt an, ob macOS als Betriebssystem verwendet wird.",
"isMacNative": "Gibt an, ob macOS auf einer Nicht-Browser-Plattform als Betriebssystem verwendet wird.",
"isMobile": "Gibt an, ob es sich bei der Plattform um einen mobilen Webbrowser handelt.",
"isWeb": "Gibt an, ob es sich bei der Plattform um einen Webbrowser handelt.",
"isWindows": "Gibt an, ob Windows als Betriebssystem verwendet wird."
"isWindows": "Gibt an, ob Windows als Betriebssystem verwendet wird.",
"productQualityType": "Qualitätstyp des VS Codes"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Abbrechen",
"moreFile": "...1 weitere Datei wird nicht angezeigt",
"moreFiles": "...{0} weitere Dateien werden nicht angezeigt"
"moreFiles": "...{0} weitere Dateien werden nicht angezeigt",
"okButton": "&&OK",
"yesButton": "&&Ja"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "Die Datei ist zu groß, um als unbenannter Editor geöffnet zu werden. Laden Sie sie zuerst in den Datei-Explorer hoch, und versuchen Sie es dann noch mal."
},
"vs/platform/files/common/files": {
"sizeB": "{0} B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Multiplikator für Scrollgeschwindigkeit bei Drücken von ALT.",
"Mouse Wheel Scroll Sensitivity": "Ein Multiplikator, der für die Mausrad-Bildlaufereignisse \"deltaX\" und \"deltaY\" verwendet werden soll.",
"automatic keyboard navigation setting": "Legt fest, ob die Tastaturnavigation in Listen und Strukturen automatisch durch Eingaben ausgelöst wird. Wenn der Wert auf \"false\" festgelegt ist, wird die Tastaturnavigation nur ausgelöst, wenn der Befehl \"list.toggleKeyboardNavigation\" ausgeführt wird. Diesem Befehl können Sie eine Tastenkombination zuweisen.",
"defaultFindMatchTypeSettingKey": "Steuert den Typ der Übereinstimmung, der beim Durchsuchen von Listen und Strukturen in der Workbench verwendet wird.",
"defaultFindMatchTypeSettingKey.contiguous": "Verwenden Sie bei der Suche eine zusammenhängende Übereinstimmung.",
"defaultFindMatchTypeSettingKey.fuzzy": "Verwenden Sie bei der Suche eine Fuzzyübereinstimmung.",
"defaultFindModeSettingKey": "Steuert den Standardsuchmodus für Listen und Strukturen in der Workbench.",
"defaultFindModeSettingKey.filter": "Filterelemente bei der Suche.",
"defaultFindModeSettingKey.highlight": "Elemente beim Suchen hervorheben. Die Navigation nach oben und unten durchläuft dann nur die markierten Elemente.",
"expand mode": "Steuert, wie Strukturordner beim Klicken auf die Ordnernamen erweitert werden. Beachten Sie, dass einige Strukturen und Listen diese Einstellung ggf. ignorieren, wenn sie nicht zutrifft.",
"horizontalScrolling setting": "Steuert, ob Listen und Strukturen ein horizontales Scrollen in der Workbench unterstützen. Warnung: Das Aktivieren dieser Einstellung kann sich auf die Leistung auswirken.",
"keyboardNavigationSettingKey": "Steuert die Tastaturnavigation in Listen und Strukturen in der Workbench. Kann \"simple\" (einfach), \"highlight\" (hervorheben) und \"filter\" (filtern) sein.",
"keyboardNavigationSettingKey.filter": "Durch das Filtern der Tastaturnavigation werden alle Elemente herausgefiltert und ausgeblendet, die nicht mit der Tastatureingabe übereinstimmen.",
"keyboardNavigationSettingKey.highlight": "Hervorheben von Tastaturnavigationshervorgebungselemente, die mit der Tastatureingabe übereinstimmen. Beim nach oben und nach unten Navigieren werden nur die hervorgehobenen Elemente durchlaufen.",
"keyboardNavigationSettingKey.simple": "Bei der einfachen Tastaturnavigation werden Elemente in den Fokus genommen, die mit der Tastatureingabe übereinstimmen. Die Übereinstimmungen gelten nur für Präfixe.",
"keyboardNavigationSettingKeyDeprecated": "Bitte verwenden Sie stattdessen „workbench.list.defaultFindMode“ und „workbench.list.typeNavigationMode“.",
"list smoothScrolling setting": "Steuert, ob Listen und Strukturen einen optimierten Bildlauf verwenden.",
"list.scrollByPage": "Steuert, ob Klicks in der Bildlaufleiste Seite für Seite scrollen.",
"multiSelectModifier": "Der Modifizierer zum Hinzufügen eines Elements in Bäumen und Listen zu einer Mehrfachauswahl mit der Maus (zum Beispiel im Explorer, in geöffneten Editoren und in der SCM-Ansicht). Die Mausbewegung \"Seitlich öffnen\" wird – sofern unterstützt – so angepasst, dass kein Konflikt mit dem Modifizierer für Mehrfachauswahl entsteht.",
"multiSelectModifier.alt": "Ist unter Windows und Linux der ALT-Taste und unter macOS der Wahltaste zugeordnet.",
"multiSelectModifier.ctrlCmd": "Ist unter Windows und Linux der STRG-Taste und unter macOS der Befehlstaste zugeordnet.",
"openModeModifier": "Steuert, wie Elemente in Strukturen und Listen mithilfe der Maus geöffnet werden (sofern unterstützt). Bei übergeordneten Elementen, deren untergeordnete Elemente sich in Strukturen befinden, steuert diese Einstellung, ob ein Einfachklick oder ein Doppelklick das übergeordnete Elemente erweitert. Beachten Sie, dass einige Strukturen und Listen diese Einstellung ggf. ignorieren, wenn sie nicht zutrifft.",
"render tree indent guides": "Steuert, ob die Struktur Einzugsführungslinien rendern soll.",
"tree indent setting": "Steuert den Struktureinzug in Pixeln.",
"typeNavigationMode": "Steuert die Funktionsweise der Typnavigation in Listen und Strukturen in der Workbench. Bei Festlegung auf „trigger“ beginnt die Typnavigation, sobald der Befehl „list.triggerTypeNavigation“ ausgeführt wird.",
"workbenchConfigurationTitle": "Workbench"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Warnung"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "Der Befehl {0} hat einen Fehler ausgelöst ({1}).",
"canNotRun": "Der Befehl \"{0}\" hat zu einem Fehler geführt.",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "häufig verwendet",
"morecCommands": "andere Befehle",
"recentlyUsed": "zuletzt verwendet"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "Editor-Befehle",
"globalCommands": "Globale Befehle",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Benutzerdefiniert",
"inputModeEntry": "Drücken Sie die EINGABETASTE, um Ihre Eingabe zu bestätigen, oder ESC, um den Vorgang abzubrechen.",
"inputModeEntryDescription": "{0} (Drücken Sie die EINGABETASTE zur Bestätigung oder ESC, um den Vorgang abzubrechen.)",
"ok": "OK",
"quickInput.back": "Zurück",
"quickInput.backWithKeybinding": "Zurück ({0})",
"quickInput.checkAll": "Aktivieren Sie alle Kontrollkästchen",
"quickInput.countSelected": "{0} ausgewählt",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} Ergebnisse",
"quickInputBox.ariaLabel": "Nehmen Sie eine Eingabe vor, um die Ergebnisse einzugrenzen."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Schnelleingabe"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Klicken, um den Befehl \"{0}\" auszuführen"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Ein zusätzlicher Rahmen um aktive Elemente, mit dem diese von anderen getrennt werden, um einen größeren Kontrast zu erreichen.",
"activeLinkForeground": "Farbe der aktiven Links.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Hintergrundfarbe der Breadcrumb-Elemente.",
"breadcrumbsFocusForeground": "Farbe der Breadcrumb-Elemente, die den Fokus haben.",
"breadcrumbsSelectedBackground": "Hintergrundfarbe des Breadcrumb-Auswahltools.",
"breadcrumbsSelectedForegound": "Die Farbe der ausgewählten Breadcrumb-Elemente.",
"breadcrumbsSelectedForeground": "Die Farbe der ausgewählten Breadcrumb-Elemente.",
"buttonBackground": "Hintergrundfarbe der Schaltfläche.",
"buttonBorder": "Rahmenfarbe der Schaltfläche.",
"buttonForeground": "Vordergrundfarbe der Schaltfläche.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Hintergrundfarbe der sekundären Schaltfläche.",
"buttonSecondaryForeground": "Sekundäre Vordergrundfarbe der Schaltfläche.",
"buttonSecondaryHoverBackground": "Hintergrundfarbe der sekundären Schaltfläche beim Daraufzeigen.",
"buttonSeparator": "Farbe des Schaltflächentrennzeichens.",
"chartsBlue": "Die in Diagrammvisualisierungen verwendete Farbe Blau.",
"chartsForeground": "Die in Diagrammen verwendete Vordergrundfarbe.",
"chartsGreen": "Die in Diagrammvisualisierungen verwendete Farbe Grün.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Hintergrundfarbe von Kontrollkästchenwidget.",
"checkbox.border": "Rahmenfarbe von Kontrollkästchenwidget.",
"checkbox.foreground": "Vordergrundfarbe von Kontrollkästchenwidget.",
"checkbox.select.background": "Hintergrundfarbe des Kontrollkästchenwidgets, wenn das Element ausgewählt ist, in dem es sich befindet.",
"checkbox.select.border": "Rahmenfarbe des Kontrollkästchenwidgets, wenn das Element ausgewählt ist, in dem es sich befindet.",
"contrastBorder": "Ein zusätzlicher Rahmen um Elemente, mit dem diese von anderen getrennt werden, um einen größeren Kontrast zu erreichen.",
"descriptionForeground": "Vordergrundfarbe für Beschreibungstexte, die weitere Informationen anzeigen, z.B. für eine Beschriftung.",
"diffDiagonalFill": "Farbe der diagonalen Füllung des Vergleichs-Editors. Die diagonale Füllung wird in Ansichten mit parallelem Vergleich verwendet.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Hintergrundfarbe für den Rand, an dem die Linien entfernt wurden.",
"diffEditorRemovedLines": "Hintergrundfarbe für Linien, die entfernt wurden. Die Farbe darf nicht deckend sein, um zugrunde liegende Dekorationen nicht auszublenden.",
"diffEditorRemovedOutline": "Konturfarbe für entfernten Text.",
"disabledForeground": "Allgemeine Vordergrundfarbe. Diese Farbe wird nur verwendet, wenn sie nicht durch eine Komponente überschrieben wird.",
"dropdownBackground": "Hintergrund für Dropdown.",
"dropdownBorder": "Rahmen für Dropdown.",
"dropdownForeground": "Vordergrund für Dropdown.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Farbe des gewählten Text für einen hohen Kontrast",
"editorSelectionHighlight": "Farbe für Bereiche mit dem gleichen Inhalt wie die Auswahl. Die Farbe darf nicht deckend sein, weil sie sonst die zugrunde liegenden Dekorationen verdeckt.",
"editorSelectionHighlightBorder": "Randfarbe für Bereiche, deren Inhalt der Auswahl entspricht.",
"editorStickyScrollBackground": "Einrastfunktion der Hintergrundfarbe für den Editor",
"editorStickyScrollHoverBackground": "Einrastfunktion beim Daraufzeigen der Hintergrundfarbe für den Editor",
"editorWarning.background": "Hintergrundfarbe für Warnungstext im Editor. Die Farbe darf nicht deckend sein, weil sie sonst die zugrunde liegenden Dekorationen verdeckt.",
"editorWarning.foreground": "Vordergrundfarbe von Warnungsunterstreichungen im Editor.",
"editorWidgetBackground": "Hintergrundfarbe von Editor-Widgets wie zum Beispiel Suchen/Ersetzen.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Hintergrundfarbe des Typfilterwidgets in Listen und Strukturen.",
"listFilterWidgetNoMatchesOutline": "Konturfarbe des Typfilterwidgets in Listen und Strukturen, wenn es keine Übereinstimmungen gibt.",
"listFilterWidgetOutline": "Konturfarbe des Typfilterwidgets in Listen und Strukturen.",
"listFilterWidgetShadow": "Schattenfarbe des Typfilterwidgets in Listen und Strukturen.",
"listFocusAndSelectionOutline": "Umrissfarbe der Liste/des Baums für das fokussierte Element, wenn die Liste/der Baum aktiv und ausgewählt ist. Eine aktive Liste/Baum hat Tastaturfokus, eine inaktive nicht.",
"listFocusBackground": "Hintergrundfarbe der Liste/Struktur für das fokussierte Element, wenn die Liste/Struktur aktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.",
"listFocusForeground": "Vordergrundfarbe der Liste/Struktur für das fokussierte Element, wenn die Liste/Struktur aktiv ist. Eine aktive Liste/Struktur hat Tastaturfokus, eine inaktive hingegen nicht.",
"listFocusHighlightForeground": "Die Vordergrundfarbe der Liste/Struktur des Treffers hebt aktiv fokussierte Elemente hervor, wenn innerhalb der Liste / der Struktur gesucht wird.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Symbolleistenhintergrund beim Halten der Maus über Aktionen",
"toolbarHoverBackground": "Symbolleistenhintergrund beim Bewegen der Maus über Aktionen",
"toolbarHoverOutline": "Symbolleistengliederung beim Bewegen der Maus über Aktionen",
"treeInactiveIndentGuidesStroke": "Strukturstrichfarbe für die Einzugslinien, die nicht aktiv sind.",
"treeIndentGuidesStroke": "Strukturstrichfarbe für die Einzugsführungslinien.",
"warningBorder": "Randfarbe der Warnfelder im Editor.",
"widgetBorder": "Die Rahmenfarbe von Widgets, z. B. Suchen/Ersetzen im Editor.",
"widgetShadow": "Schattenfarbe von Widgets wie zum Beispiel Suchen/Ersetzen innerhalb des Editors."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Symbol für Aktion zum Schließen in Widgets"
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Abbrechen",
"cannotResourceRedoDueToInProgressUndoRedo": "\"{0}\" konnte nicht wiederholt werden, weil bereits ein Vorgang zum Rückgängigmachen oder Wiederholen durchgeführt wird.",
"cannotResourceUndoDueToInProgressUndoRedo": "\"{0}\" konnte nicht rückgängig gemacht werden, weil bereits ein Vorgang zum Rückgängigmachen oder Wiederholen durchgeführt wird.",
"cannotWorkspaceRedo": "\"{0}\" konnte nicht in allen Dateien wiederholt werden. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "\"{0}\" konnte nicht für alle Dateien rückgängig gemacht werden, weil bereits ein Vorgang zum Rückgängigmachen oder Wiederholen für \"{1}\" durchgeführt wird.",
"confirmDifferentSource": "Möchten Sie \"{0}\" rückgängig machen?",
"confirmDifferentSource.no": "Nein",
"confirmDifferentSource.yes": "Ja",
"confirmDifferentSource.yes": "&&Ja",
"confirmWorkspace": "Möchten Sie \"{0}\" für alle Dateien rückgängig machen?",
"externalRemoval": "Die folgenden Dateien wurden geschlossen und auf dem Datenträger geändert: {0}.",
"noParallelUniverses": "Die folgenden Dateien wurden auf inkompatible Weise geändert: {0}.",
"nok": "Datei rückgängig machen",
"ok": "In {0} Dateien rückgängig machen"
"nok": "&&Datei rückgängig machen",
"ok": "&&In {0} Dateien rückgängig machen"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Codearbeitsbereich"

388
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/es.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Más Acciones..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Cerrar cuadro de diálogo",
"dialogErrorMessage": "Error",
"dialogInfoMessage": "Información",
"dialogPendingMessage": "En curso",
"dialogWarningMessage": "Advertencia",
"ok": "Aceptar"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Más Acciones..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "entrada"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Coincidir mayúsculas y minúsculas",
"regexDescription": "Usar expresión regular",
"wordsDescription": "Solo palabras completas"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "entrada",
"label.preserveCaseToggle": "Conservar may/min"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Sin enlazar"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Seleccionar cuadro"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Más Acciones..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Borrar",
"disable filter on type": "Desactivar filtro en tipo",
"empty": "No se encontraron elementos",
"enable filter on type": "Activar filtro en el tipo",
"found": "{0} de {1} elementos coincidentes"
"close": "Cerrar",
"filter": "Filtrar",
"fuzzySearch": "Coincidencia aproximada",
"not found": "No se encontraron elementos.",
"type to filter": "Escriba texto para filtrar",
"type to search": "Escriba texto para buscar"
},
"vs/base/common/actions": {
"submenu.empty": "(vacío)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Personalizado",
"inputModeEntry": "Presione \"Entrar\" para confirmar su entrada o \"Esc\" para cancelar",
"inputModeEntryDescription": "{0} (Presione \"Entrar\" para confirmar o \"Esc\" para cancelar)",
"ok": "Aceptar",
"quickInput.back": "Atrás",
"quickInput.backWithKeybinding": "Atrás ({0})",
"quickInput.countSelected": "{0} seleccionados",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} resultados",
"quickInputBox.ariaLabel": "Escriba para restringir los resultados."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Entrada rápida"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "El editor no es accesible en este momento. Pulse {0} para ver las opciones.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Deshacer"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "El número de cursores se ha limitado a {0}."
"cursors.maximum": "El número de cursores se ha limitado a {0}. Considere la posibilidad de usar [buscar y reemplazar](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) para realizar cambios mayores o aumentar la configuración del límite de varios cursores del editor.",
"goToSetting": "Aumentar el límite de varios cursores"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " usar Mayús + F7 para navegar por los cambios",
"diff.tooLarge": "Los archivos no se pueden comparar porque uno de ellos es demasiado grande.",
"diffInsertIcon": "Decoración de línea para las inserciones en el editor de diferencias.",
"diffRemoveIcon": "Decoración de línea para las eliminaciones en el editor de diferencias."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Controla si el editor muestra CodeLens.",
"detectIndentation": "Controla si \"#editor.tabSize#\" y \"#editor.insertSpaces#\" se detectarán automáticamente al abrir un archivo en función del contenido de este.",
"detectIndentation": "Controla si {0} y {1} se detectan automáticamente al abrir un archivo en función del contenido de este.",
"diffAlgorithm.experimental": "Usa un algoritmo de comparación experimental.",
"diffAlgorithm.smart": "Usa el algoritmo de comparación predeterminado.",
"editor.experimental.asyncTokenization": "Controla si la tokenización debe producirse de forma asincrónica en un rol de trabajo.",
"editorConfigurationTitle": "Editor",
"ignoreTrimWhitespace": "Cuando está habilitado, el editor de diferencias omite los cambios en los espacios en blanco iniciales o finales.",
"insertSpaces": "Insertar espacios al presionar \"TAB\". Este valor se invalida en función del contenido del archivo cuando \"#editor.detectIndentation#\" está activado. ",
"indentSize": "Número de espacios usados para la sangría o \"tabSize\" para usar el valor de \"#editor.tabSize#\". Esta configuración se invalida en función del contenido del archivo cuando \"#editor.detectIndentation#\" está activado.",
"insertSpaces": "Insertar espacios al presionar \"TAB\". Este valor se invalida en función del contenido del archivo cuando {0} está activado.",
"largeFileOptimizations": "Manejo especial para archivos grandes para desactivar ciertas funciones de memoria intensiva.",
"maxComputationTime": "Tiempo de espera en milisegundos después del cual se cancela el cálculo de diferencias. Utilice 0 para no usar tiempo de espera.",
"maxFileSize": "Tamaño máximo de archivo en MB para el que calcular diferencias. Use 0 para no limitar.",
"maxTokenizationLineLength": "Las lineas por encima de esta longitud no se tokenizarán por razones de rendimiento.",
"renderIndicators": "Controla si el editor de diferencias muestra los indicadores +/- para los cambios agregados o quitados.",
"renderMarginRevertIcon": "Cuando está habilitado, el editor de diferencias muestra flechas en su margen de glifo para revertir los cambios.",
"schema.brackets": "Define los corchetes que aumentan o reducen la sangría.",
"schema.closeBracket": "Secuencia de cadena o corchete de cierre.",
"schema.colorizedBracketPairs": "Define los pares de corchetes coloreados por su nivel de anidamiento si está habilitada la coloración de par de corchetes.",
@ -140,14 +161,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.true": "El resaltado semántico está habilitado para todos los temas de color.",
"sideBySide": "Controla si el editor de diferencias muestra las diferencias en paralelo o alineadas.",
"stablePeek": "Mantiene abiertos los editores interactivos, incluso al hacer doble clic en su contenido o presionar \"Escape\".",
"tabSize": "El número de espacios a los que equivale una tabulación. Este valor se invalida en función del contenido del archivo cuando \"#editor.detectIndentation#\" está activado.",
"tabSize": "El número de espacios a los que equivale una tabulación. Este valor se invalida en función del contenido del archivo cuando {0} está activado.",
"trimAutoWhitespace": "Quitar el espacio en blanco final autoinsertado.",
"wordBasedSuggestions": "Habilita sugerencias basadas en palabras.",
"wordBasedSuggestionsMode": "Controla de qué documentos se calculan las finalizaciones basadas en palabras.",
"wordBasedSuggestionsMode.allDocuments": "Sugerir palabras de todos los documentos abiertos.",
"wordBasedSuggestionsMode.currentDocument": "Sugerir palabras solo del documento activo.",
"wordBasedSuggestionsMode.matchingDocuments": "Sugerir palabras de todos los documentos abiertos del mismo idioma.",
"wordWrap.inherit": "Las líneas se ajustarán en función de la configuración de \"#editor.wordWrap#\".",
"wordWrap.inherit": "Las líneas se ajustarán en función de la configuración de {0}.",
"wordWrap.off": "Las líneas no se ajustarán nunca.",
"wordWrap.on": "Las líneas se ajustarán en el ancho de la ventanilla."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Controla si las sugerencias deben aceptarse con \"Entrar\", además de \"TAB\". Ayuda a evitar la ambigüedad entre insertar nuevas líneas o aceptar sugerencias.",
"acceptSuggestionOnEnterSmart": "Aceptar solo una sugerencia con \"Entrar\" cuando realiza un cambio textual.",
"accessibilityPageSize": "Controla el número de líneas del editor que pueden ser leídas por un lector de pantalla a la vez. Cuando detectamos un lector de pantalla, fijamos automáticamente el valor por defecto en 500. Advertencia: esto tiene una implicación de rendimiento para números mayores que el predeterminado.",
"accessibilitySupport": "Controla si el editor se debe ejecutar en un modo optimizado para lectores de pantalla. Si se activa, se deshabilitará el ajuste de líneas.",
"accessibilitySupport.auto": "El editor usará API de plataforma para detectar cuándo está conectado un lector de pantalla.",
"accessibilitySupport.off": "El editor nunca se optimizará para su uso con un lector de pantalla.",
"accessibilitySupport.on": "El editor se optimizará de forma permanente para su uso con un lector de pantalla. El ajuste de líneas se deshabilitará.",
"accessibilitySupport": "Controla si la interfaz de usuario debe ejecutarse en un modo en el que esté optimizada para lectores de pantalla.",
"accessibilitySupport.auto": "Usar las API de la plataforma para detectar cuándo se conecta un lector de pantalla",
"accessibilitySupport.off": "Supongamos que no hay un lector de pantalla conectado",
"accessibilitySupport.on": "Optimizar para usar con un lector de pantalla",
"alternativeDeclarationCommand": "Id. de comando alternativo que se está ejecutando cuando el resultado de \"Ir a declaración\" es la ubicación actual.",
"alternativeDefinitionCommand": "Identificador de comando alternativo que se ejecuta cuando el resultado de \"Ir a definición\" es la ubicación actual.",
"alternativeImplementationCommand": "Id. de comando alternativo que se está ejecutando cuando el resultado de \"Ir a implementación\" es la ubicación actual.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Controla si el editor debe cerrar automáticamente las comillas después de que el usuario agrega uma comilla de apertura.",
"autoIndent": "Controla si el editor debe ajustar automáticamente la sangría mientras los usuarios escriben, pegan, mueven o sangran líneas.",
"autoSurround": "Controla si el editor debe rodear automáticamente las selecciones al escribir comillas o corchetes.",
"bracketPairColorization.enabled": "Controla si está habilitada o no la coloración de pares de corchetes. Use `#workbench.colorCustomizations#` para invalidar los colores de resaltado de corchete.",
"bracketPairColorization.enabled": "Controla si está habilitada o no la coloración de pares de corchetes. Use {0} para invalidar los colores de resaltado de corchete.",
"bracketPairColorization.independentColorPoolPerBracketType": "Controla si cada tipo de corchete tiene su propio grupo de colores independiente.",
"codeActions": "Habilita la bombilla de acción de código en el editor.",
"codeLens": "Controla si el editor muestra CodeLens.",
"codeLensFontFamily": "Controla la familia de fuentes para CodeLens.",
"codeLensFontSize": "Controla el tamaño de fuente de CodeLens en píxeles. Cuando se establece en \"0\", se usa el 90 % de \"#editor.fontSize#\".",
"codeLensFontSize": "Controla el tamaño de fuente de CodeLens en píxeles. Cuando se establece en 0, se usa el 90 % de \"#editor.fontSize#\".",
"colorDecorators": "Controla si el editor debe representar el Selector de colores y los elementos Decorator de color en línea.",
"colorDecoratorsLimit": "Controla el número máximo de decoradores de color que se pueden representar en un editor a la vez.",
"columnSelection": "Habilite que la selección con el mouse y las teclas esté realizando la selección de columnas.",
"comments.ignoreEmptyLines": "Controla si las líneas vacías deben ignorarse con la opción de alternar, agregar o quitar acciones para los comentarios de línea.",
"comments.insertSpace": "Controla si se inserta un carácter de espacio al comentar.",
"copyWithSyntaxHighlighting": "Controla si el resaltado de sintaxis debe ser copiado al portapapeles.",
"cursorBlinking": "Controla el estilo de animación del cursor.",
"cursorSmoothCaretAnimation": "Controla si la animación suave del cursor debe estar habilitada.",
"cursorSmoothCaretAnimation.explicit": "La animación de símbolo de intercalación suave solo se habilita cuando el usuario mueve el cursor con un gesto explícito.",
"cursorSmoothCaretAnimation.off": "La animación del símbolo de intercalación suave está deshabilitada.",
"cursorSmoothCaretAnimation.on": "La animación de símbolo de intercalación suave siempre está habilitada.",
"cursorStyle": "Controla el estilo del cursor.",
"cursorSurroundingLines": "Controla el número mínimo de líneas iniciales y finales visibles que rodean al cursor. En algunos otros editores, se conoce como \"scrollOff\" o \"scrollOffset\".",
"cursorSurroundingLines": "Controla el número mínimo de líneas iniciales visibles (mínimo 0) y líneas finales (mínimo 1) que rodean el cursor. Se conoce como \"scrollOff\" o \"scrollOffset\" en otros editores.",
"cursorSurroundingLinesStyle": "Controla cuando se debe aplicar \"cursorSurroundingLines\".",
"cursorSurroundingLinesStyle.all": "\"cursorSurroundingLines\" se aplica siempre.",
"cursorSurroundingLinesStyle.default": "Solo se aplica \"cursorSurroundingLines\" cuando se desencadena mediante el teclado o la API.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Controla si el gesto del mouse Ir a definición siempre abre el widget interactivo.",
"deprecated": "Esta configuración está en desuso. Use configuraciones separadas como \"editor.suggest.showKeyword\" o \"editor.suggest.showSnippets\" en su lugar.",
"dragAndDrop": "Controla si el editor debe permitir mover las selecciones mediante arrastrar y colocar.",
"dropIntoEditor.enabled": "Controla si puede arrastrar y colocar un archivo en un editor de texto manteniendo presionada la tecla `mayús` (en lugar de abrir el archivo en un editor).",
"editor.autoClosingBrackets.beforeWhitespace": "Cerrar automáticamente los corchetes cuando el cursor esté a la izquierda de un espacio en blanco.",
"editor.autoClosingBrackets.languageDefined": "Utilizar las configuraciones del lenguaje para determinar cuándo cerrar los corchetes automáticamente.",
"editor.autoClosingDelete.auto": "Quite los corchetes o las comillas de cierre adyacentes solo si se insertaron automáticamente.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Habilita guías horizontales como adición a guías de par de corchetes verticales.",
"editor.guides.highlightActiveBracketPair": "Controla si el editor debe resaltar el par de corchetes activo.",
"editor.guides.highlightActiveIndentation": "Controla si el editor debe resaltar la guía de sangría activa.",
"editor.guides.highlightActiveIndentation.always": "Resalta la guía de sangría activa incluso si se resaltan las guías de corchetes.",
"editor.guides.highlightActiveIndentation.false": "No resalta la guía de sangría activa.",
"editor.guides.highlightActiveIndentation.true": "Resalta la guía de sangría activa.",
"editor.guides.indentation": "Controla si el editor debe representar guías de sangría.",
"editor.inlayHints.off": "Las sugerencias de incrustación están deshabilitadas",
"editor.inlayHints.offUnlessPressed": "Las sugerencias de incrustación están ocultas de forma predeterminada y se muestran al mantener presionado {0}",
"editor.inlayHints.on": "Las sugerencias de incrustación están habilitadas",
"editor.inlayHints.onUnlessPressed": "Las sugerencias de incrustación se muestran de forma predeterminada y se ocultan cuando se mantiene presionado {0}",
"editor.stickyScroll": "Muestra los ámbitos actuales anidados durante el desplazamiento en la parte superior del editor.",
"editor.stickyScroll.": "Define el número máximo de líneas rápidas que se mostrarán.",
"editor.suggest.matchOnWordStartOnly": "Cuando se activa el filtro IntelliSense se requiere que el primer carácter coincida con el inicio de una palabra. Por ejemplo, \"c\" en \"Consola\" o \"WebContext\" but _not_ on \"descripción\". Si se desactiva, IntelliSense mostrará más resultados, pero los ordenará según la calidad de la coincidencia.",
"editor.suggest.showClasss": "Cuando está habilitado, IntelliSense muestra sugerencias de tipo \"class\".",
"editor.suggest.showColors": "Cuando está habilitado, IntelliSense muestra sugerencias de \"color\".",
"editor.suggest.showConstants": "Cuando está habilitado, IntelliSense muestra sugerencias de tipo \"constant\".",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Cuando está habilitado, IntelliSense muestra sugerencias de tipo \"variable\".",
"editorViewAccessibleLabel": "Contenido del editor",
"emptySelectionClipboard": "Controla si al copiar sin selección se copia la línea actual.",
"experimentalWhitespaceRendering": "Controla si los espacios en blanco se representan con un nuevo método experimental.",
"experimentalWhitespaceRendering.font": "Use un nuevo método de representación con caracteres de fuente.",
"experimentalWhitespaceRendering.off": "Use el método de representación estable.",
"experimentalWhitespaceRendering.svg": "Use un nuevo método de representación con svgs.",
"fastScrollSensitivity": "Multiplicador de la velocidad de desplazamiento al presionar \"Alt\".",
"find.addExtraSpaceOnTop": "Controla si Encontrar widget debe agregar más líneas en la parte superior del editor. Si es true, puede desplazarse más allá de la primera línea cuando Encontrar widget está visible.",
"find.autoFindInSelection": "Controla la condición para activar la búsqueda en la selección de forma automática.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Habilita o deshabilita las ligaduras tipográficas (características de fuente \"calt\" y \"liga\"). Cámbielo a una cadena para el control específico de la propiedad de CSS \"font-feature-settings\".",
"fontLigaturesGeneral": "Configura las ligaduras tipográficas o las características de fuente. Puede ser un valor booleano para habilitar o deshabilitar las ligaduras o bien una cadena para el valor de la propiedad \"font-feature-settings\" de CSS.",
"fontSize": "Controla el tamaño de fuente en píxeles.",
"fontVariationSettings": "Propiedad CSS explícita 'font-variation-settings'. En su lugar, se puede pasar un valor booleano si solo es necesario traducir font-weight a font-variation-settings.",
"fontVariations": "Habilita o deshabilita la traducción del grosor de font-weight a font-variation-settings. Cambie esto a una cadena para el control específico de la propiedad CSS 'font-variation-settings'.",
"fontVariationsGeneral": "Configura variaciones de fuente. Puede ser un booleano para habilitar o deshabilitar la traducción de font-weight a font-variation-settings o una cadena para el valor de la propiedad CSS 'font-variation-settings'.",
"fontWeight": "Controla el grosor de la fuente. Acepta las palabras clave \"normal\" y \"negrita\" o los números entre 1 y 1000.",
"fontWeightErrorMessage": "Solo se permiten las palabras clave \"normal\" y \"negrita\" o los números entre 1 y 1000.",
"formatOnPaste": "Controla si el editor debe dar formato automáticamente al contenido pegado. Debe haber disponible un formateador capaz de aplicar formato a un rango dentro de un documento. ",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Controla si se muestra la información al mantener el puntero sobre un elemento.",
"hover.sticky": "Controla si la información que aparece al mantener el puntero sobre un elemento permanece visible al mover el mouse sobre este.",
"inlayHints.enable": "Habilita las sugerencias de incrustación en el editor.",
"inlayHints.fontFamily": "Controla la familia de fuentes de sugerencias de incrustación en el editor. Cuando se establece en vacío, se usa \"#editor.fontFamily#\".",
"inlayHints.fontSize": "Controla el tamaño de fuente de las sugerencias de incrustación en el editor. Se usa un valor predeterminado del 90 % de \"#editor.fontSize#\" cuando el valor configurado es menor que \"5\" o mayor que el tamaño de fuente del editor.",
"inlayHints.fontFamily": "Controla la familia de fuentes de sugerencias de incrustación en el editor. Cuando se establece en vacío, se usa el {0}.",
"inlayHints.fontSize": "Controla el tamaño de fuente de las sugerencias de incrustación en el editor. Como valor predeterminado, se usa {0} cuando el valor configurado es menor que {1} o mayor que el tamaño de fuente del editor.",
"inlayHints.padding": "Habilita el relleno alrededor de las sugerencias de incrustación en el editor.",
"inline": "Las sugerencias rápidas se muestran como texto fantasma",
"inlineSuggest.enabled": "Controla si se deben mostrar automáticamente las sugerencias alineadas en el editor.",
"inlineSuggest.showToolbar": "Controla cuándo mostrar la barra de herramientas de sugerencias insertadas.",
"inlineSuggest.showToolbar.always": "Muestra la barra de herramientas de sugerencias insertadas cada vez que se muestra una sugerencia insertada.",
"inlineSuggest.showToolbar.onHover": "Muestra la barra de herramientas de sugerencias insertadas al mantener el puntero sobre una sugerencia insertada.",
"letterSpacing": "Controla el espacio entre letras en píxeles.",
"lineHeight": "Controla el alto de línea. \r\n - Use 0 para calcular automáticamente el alto de línea a partir del tamaño de la fuente.\r\n - Los valores entre 0 y 8 se usarán como multiplicador con el tamaño de fuente.\r\n - Los valores mayores o igual que 8 se usarán como valores efectivos.",
"lineNumbers": "Controla la visualización de los números de línea.",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "Controla si el editor tiene habilitada la edición vinculada. Dependiendo del lenguaje, los símbolos relacionados (por ejemplo, las etiquetas HTML) se actualizan durante la edición.",
"links": "Controla si el editor debe detectar vínculos y hacerlos interactivos.",
"matchBrackets": "Resaltar paréntesis coincidentes.",
"minimap.autohide": "Controla si el minimapa se oculta automáticamente.",
"minimap.enabled": "Controla si se muestra el minimapa.",
"minimap.maxColumn": "Limite el ancho del minimapa para representar como mucho un número de columnas determinado.",
"minimap.renderCharacters": "Represente los caracteres reales en una línea, por oposición a los bloques de color.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "El minimapa tiene el mismo tamaño que el contenido del editor (y podría desplazarse).",
"mouseWheelScrollSensitivity": "Se usará un multiplicador en los eventos de desplazamiento de la rueda del mouse \"deltaX\" y \"deltaY\". ",
"mouseWheelZoom": "Ampliar la fuente del editor cuando se use la rueda del mouse mientras se presiona \"Ctrl\".",
"multiCursorLimit": "Controla el número máximo de cursores que puede haber en un editor activo a la vez.",
"multiCursorMergeOverlapping": "Combinar varios cursores cuando se solapan.",
"multiCursorModifier": "El modificador que se usará para agregar varios cursores con el mouse. Los gestos del mouse Ir a definición y Abrir vínculo se adaptarán de modo que no entren en conflicto con el modificador multicursor. [Más información](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "El modificador que se usará para agregar varios cursores con el mouse. Los gestos del mouse Ir a definición y Abrir vínculo se adaptarán de modo que no entren en conflicto con el [modificador multicursor](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier.alt": "Se asigna a \"Alt\" en Windows y Linux y a \"Opción\" en macOS.",
"multiCursorModifier.ctrlCmd": "Se asigna a \"Control\" en Windows y Linux y a \"Comando\" en macOS.",
"multiCursorPaste": "Controla el pegado cuando el recuento de líneas del texto pegado coincide con el recuento de cursores.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Controla si se debe enfocar el editor en línea o el árbol en el widget de vista.",
"peekWidgetDefaultFocus.editor": "Enfocar el editor al abrir la inspección",
"peekWidgetDefaultFocus.tree": "Enfocar el árbol al abrir la inspección",
"quickSuggestions": "Controla si deben mostrarse sugerencias automáticamente mientras se escribe.",
"quickSuggestions": "Controla si las sugerencias deben mostrarse automáticamente al escribir. Puede controlarse para la escritura en comentarios, cadenas y otro código. Las sugerencias rápidas pueden configurarse para mostrarse como texto fantasma o con el widget de sugerencias. Tenga también en cuenta la configuración '{0}' que controla si las sugerencias son desencadenadas por caracteres especiales.",
"quickSuggestions.comments": "Habilita sugerencias rápidas en los comentarios.",
"quickSuggestions.other": "Habilita sugerencias rápidas fuera de las cadenas y los comentarios.",
"quickSuggestions.strings": "Habilita sugerencias rápidas en las cadenas.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Controla cuándo se muestran los controles de plegado en el medianil.",
"showFoldingControls.always": "Mostrar siempre los controles de plegado.",
"showFoldingControls.mouseover": "Mostrar solo los controles de plegado cuando el mouse está sobre el medianil.",
"showFoldingControls.never": "No mostrar nunca los controles de plegado y reducir el tamaño del medianil.",
"showUnused": "Controla el fundido de salida del código no usado.",
"smoothScrolling": "Controla si el editor se desplazará con una animación.",
"snippetSuggestions": "Controla si se muestran los fragmentos de código con otras sugerencias y cómo se ordenan.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Emula el comportamiento de selección de los caracteres de tabulación al usar espacios para la sangría. La selección se aplicará a las tabulaciones.",
"suggest.filterGraceful": "Controla si el filtrado y la ordenación de sugerencias se tienen en cuenta para los errores ortográficos pequeños.",
"suggest.insertMode": "Controla si las palabras se sobrescriben al aceptar la finalización. Tenga en cuenta que esto depende de las extensiones que participan en esta característica.",
"suggest.insertMode.always": "Seleccione siempre una sugerencia cuando se desencadene IntelliSense automáticamente.",
"suggest.insertMode.insert": "Inserte la sugerencia sin sobrescribir el texto a la derecha del cursor.",
"suggest.insertMode.never": "Nunca seleccione una sugerencia cuando desencadene IntelliSense automáticamente.",
"suggest.insertMode.replace": "Inserte la sugerencia y sobrescriba el texto a la derecha del cursor.",
"suggest.insertMode.whenQuickSuggestion": "Seleccione una sugerencia solo cuando desencadene IntelliSense mientras escribe.",
"suggest.insertMode.whenTriggerCharacter": "Seleccione una sugerencia solo cuando desencadene IntelliSense desde un carácter de desencadenador.",
"suggest.localityBonus": "Controla si la ordenación mejora las palabras que aparecen cerca del cursor.",
"suggest.maxVisibleSuggestions.dep": "La configuración está en desuso. Ahora puede cambiarse el tamaño del widget de sugerencias.",
"suggest.preview": "Controla si se puede obtener una vista previa del resultado de la sugerencia en el editor.",
"suggest.selectionMode": "Controla si se selecciona una sugerencia cuando se muestra el widget. Tenga en cuenta que esto solo se aplica a las sugerencias desencadenadas automáticamente (`#editor.quickSuggestions#` y `#editor.suggestOnTriggerCharacters#`) y que siempre se selecciona una sugerencia cuando se invoca explícitamente, por ejemplo, a través de 'Ctrl+Espacio'.",
"suggest.shareSuggestSelections": "Controla si las selecciones de sugerencias recordadas se comparten entre múltiples áreas de trabajo y ventanas (necesita \"#editor.suggestSelection#\").",
"suggest.showIcons": "Controla si mostrar u ocultar iconos en sugerencias.",
"suggest.showInlineDetails": "Controla si los detalles de sugerencia se muestran incorporados con la etiqueta o solo en el widget de detalles.",
"suggest.showStatusBar": "Controla la visibilidad de la barra de estado en la parte inferior del widget de sugerencias.",
"suggest.snippetsPreventQuickSuggestions": "Controla si un fragmento de código activo impide sugerencias rápidas.",
"suggestFontSize": "Tamaño de la fuente para el widget de sugerencias. Cuando se establece a `0`, se utilizará el valor `#editor.fontSize#`.",
"suggestLineHeight": "Altura de la línea del widget de sugerencias. Cuando se establece en \"0\", se usa el valor \"#editor.lineHeight#\". El valor mínimo es 8.",
"suggestFontSize": "Tamaño de fuente del widget de sugerencias. Cuando se establece en {0}, se usa el valor de {1}.",
"suggestLineHeight": "Alto de línea para el widget de sugerencias. Cuando se establece en {0}, se usa el valor de {1}. El valor mínimo es 8.",
"suggestOnTriggerCharacters": "Controla si deben aparecer sugerencias de forma automática al escribir caracteres desencadenadores.",
"suggestSelection": "Controla cómo se preseleccionan las sugerencias cuando se muestra la lista,",
"suggestSelection.first": "Seleccionar siempre la primera sugerencia.",
@ -410,6 +465,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Deshabilitar los complementos para pestañas.",
"tabCompletion.on": "La pestaña se completará insertando la mejor sugerencia de coincidencia encontrada al presionar la pestaña",
"tabCompletion.onlySnippets": "La pestaña se completa con fragmentos de código cuando su prefijo coincide. Funciona mejor cuando las 'quickSuggestions' no están habilitadas.",
"tabFocusMode": "Controla si el editor recibe las pestañas o las aplaza al área de trabajo para la navegación.",
"unfoldOnClickAfterEndOfLine": "Controla si al hacer clic en el contenido vacío después de una línea plegada se desplegará la línea.",
"unicodeHighlight.allowedCharacters": "Define los caracteres permitidos que no se resaltan.",
"unicodeHighlight.allowedLocales": "Los caracteres Unicode que son comunes en las configuraciones regionales permitidas no se resaltan.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Los terminadores de línea no habituales se omiten.",
"unusualLineTerminators.prompt": "Advertencia de terminadores de línea inusuales que se quitarán.",
"useTabStops": "La inserción y eliminación del espacio en blanco sigue a las tabulaciones.",
"wordBreak": "Controla las reglas de salto de palabra usadas para texto chino, japonés o coreano (CJK).",
"wordBreak.keepAll": "Los saltos de palabra no deben usarse para texto chino, japonés o coreano (CJK). El comportamiento del texto distinto a CJK es el mismo que el normal.",
"wordBreak.normal": "Use la regla de salto de línea predeterminada.",
"wordSeparators": "Caracteres que se usarán como separadores de palabras al realizar operaciones o navegaciones relacionadas con palabras.",
"wordWrap": "Controla cómo deben ajustarse las líneas.",
"wordWrap.bounded": "Las líneas se ajustarán al valor que sea inferior: el tamaño de la ventanilla o el valor de \"#editor.wordWrapColumn#\".",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "A las líneas ajustadas se les aplica una sangría de +1 respecto al elemento primario.",
"wrappingIndent.none": "No hay sangría. Las líneas ajustadas comienzan en la columna 1.",
"wrappingIndent.same": "A las líneas ajustadas se les aplica la misma sangría que al elemento primario.",
"wrappingStrategy": "Controla el algoritmo que calcula los puntos de ajuste.",
"wrappingStrategy": "Controla el algoritmo que calcula los puntos de ajuste. Tenga en cuenta que, en el modo de accesibilidad, se usará el modo avanzado para obtener la mejor experiencia.",
"wrappingStrategy.advanced": "Delega el cálculo de puntos de ajuste en el explorador. Es un algoritmo lento, que podría causar bloqueos para archivos grandes, pero funciona correctamente en todos los casos.",
"wrappingStrategy.simple": "Se supone que todos los caracteres son del mismo ancho. Este es un algoritmo rápido que funciona correctamente para fuentes monoespaciales y ciertos scripts (como caracteres latinos) donde los glifos tienen el mismo ancho."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Color de fondo de las guías de par de corchetes inactivos (6). Requiere habilitar guías de par de corchetes.",
"editorCodeLensForeground": "Color principal de lentes de código en el editor",
"editorCursorBackground": "Color de fondo del cursor de edición. Permite personalizar el color del caracter solapado por el bloque del cursor.",
"editorDimmedLineNumber": "Color de la línea final del editor cuando editor.renderFinalNewline se establece en atenuado.",
"editorGhostTextBackground": "Color de fondo del texto fantasma en el editor.",
"editorGhostTextBorder": "Color del borde del texto fantasma en el editor.",
"editorGhostTextForeground": "Color de primer plano del texto fantasma en el editor.",
"editorGutter": "Color de fondo del margen del editor. Este espacio contiene los márgenes de glifos y los números de línea.",
"editorIndentGuides": "Color de las guías de sangría del editor.",
"editorLineNumbers": "Color de números de línea del editor.",
"editorOverviewRulerBackground": "Color de fondo de la regla de información general del editor. Solo se usa cuando el minimapa está habilitado y está ubicado en el lado derecho del editor.",
"editorOverviewRulerBackground": "Color de fondo de la regla de información general del editor.",
"editorOverviewRulerBorder": "Color del borde de la regla de visión general.",
"editorRuler": "Color de las reglas del editor",
"editorUnicodeHighlight.background": "Color de borde usado para resaltar caracteres unicode.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Al presionar TAB en el editor actual, el foco se mueve al siguiente elemento activable. El comando {0} no se puede desencadenar actualmente mediante un enlace de teclado.",
"toggleHighContrast": "Alternar tema de contraste alto"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} caracteres",
"showMore": "Mostrar más ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Delimitador establecido en {0}:{1}",
"cancelSelectionAnchor": "Cancelar el delimitador de la selección",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Copiar como",
"miCopy": "&&Copiar",
"miCut": "Cor&&tar",
"miPaste": "&&Pegar"
"miPaste": "&&Pegar",
"share": "Compartir"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Se ha producido un error desconocido al aplicar la acción de código"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Se ha producido un error desconocido al aplicar la acción de código",
"args.schema.apply": "Controla cuándo se aplican las acciones devueltas.",
"args.schema.apply.first": "Aplicar siempre la primera acción de código devuelto.",
"args.schema.apply.ifSingle": "Aplicar la primera acción de código devuelta si solo hay una.",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Organizar Importaciones",
"quickfix.trigger.label": "Corrección Rápida",
"refactor.label": "Refactorizar...",
"refactor.preview.label": "Refactorizar con vista previa...",
"source.label": "Acción de código fuente..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Activar/desactivar la visualización de los encabezados de los grupos en el menú de Acción de código."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Reescribir...",
"codeAction.widget.id.extract": "Extraer...",
"codeAction.widget.id.inline": "Alineado...",
"codeAction.widget.id.more": "Más Acciones...",
"codeAction.widget.id.move": "Mover...",
"codeAction.widget.id.quickfix": "Corrección rápida...",
"codeAction.widget.id.source": "Acción de origen...",
"codeAction.widget.id.surround": "Rodear con..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Ocultar deshabilitado",
"showMoreActions": "Mostrar elementos deshabilitados"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Mostrar acciones de código",
"codeActionWithKb": "Mostrar acciones de código ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "&&Alternar comentario de línea"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Mostrar menú contextual del editor"
"action.showContextMenu.label": "Mostrar menú contextual del editor",
"context.minimap.minimap": "Minimapa",
"context.minimap.renderCharacters": "Representar caracteres",
"context.minimap.size": "Tamaño vertical",
"context.minimap.size.fill": "Relleno",
"context.minimap.size.fit": "Ajustar",
"context.minimap.size.proportional": "Proporcional",
"context.minimap.slider": "Control deslizante",
"context.minimap.slider.always": "Siempre",
"context.minimap.slider.mouseover": "Pasar el mouse"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Habilita o deshabilita la ejecución de ediciones desde extensiones al pegar."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Ejecutando controladores de pegado..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Cursor Rehacer",
"cursor.undo": "Cursor Deshacer"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Ejecutando controladores de destino..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Indica si el editor ejecuta una operación que se puede cancelar como, por ejemplo, \"Inspeccionar referencias\""
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Invalida la marca \"Caso matemático\".\r\nLa marca no se guardará para el futuro.\r\n0: No hacer nada\r\n1: True\r\n2: False",
"actions.find.preserveCaseOverride": "Invalida la marca \"Conservar mayúsculas y minúsculas.\r\nLa marca no se guardará para el futuro.\r\n0: No hacer nada\r\n1: True\r\n2: False",
"actions.find.wholeWordOverride": "Invalida la marca \"Hacer coincidir palabra completa”.\r\nLa marca no se guardará para el futuro.\r\n0: No hacer nada\r\n1: True\r\n2: False",
"findMatchAction.goToMatch": "Ir a Coincidencia...",
"findMatchAction.inputPlaceHolder": "Escriba un número para ir a una coincidencia específica (entre 1 y {0})",
"findMatchAction.inputValidationMessage": "Escriba un número entre 1 y {0}",
"findNextMatchAction": "Buscar siguiente",
"findPreviousMatchAction": "Buscar anterior",
"miFind": "&&Buscar",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Sólo los primeros {0} resultados son resaltados, pero todas las operaciones de búsqueda trabajan en todo el texto."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Color del control plegable en el medianil del editor.",
"createManualFoldRange.label": "Crear rango de plegado a partir de la selección",
"foldAction.label": "Plegar",
"foldAllAction.label": "Plegar todo",
"foldAllBlockComments.label": "Cerrar todos los comentarios de bloque",
"foldAllExcept.label": "Plegar todas las regiones excepto las seleccionadas",
"foldAllMarkerRegions.label": "Plegar todas las regiones",
"foldBackgroundBackground": "Color de fondo detrás de los rangos plegados. El color no debe ser opaco para no ocultar las decoraciones subyacentes.",
"foldLevelAction.label": "Nivel de plegamiento {0}",
"foldRecursivelyAction.label": "Plegar de forma recursiva",
"gotoNextFold.label": "Ir al rango de plegado siguiente",
"gotoParentFold.label": "Ir al plegado primario",
"gotoPreviousFold.label": "Ir al rango de plegado anterior",
"maximum fold ranges": "El número de regiones que se pueden plegar está limitado a un máximo de {0}. Aumente la opción de configuración ['Plegamiento de regiones máximas'](command:workbench.action.openSettings?[\" editor.foldingMaximumRegions\"]) para habilitar más.",
"removeManualFoldingRanges.label": "Quitar rangos de plegado manuales",
"toggleFoldAction.label": "Alternar plegado",
"unFoldRecursivelyAction.label": "Desplegar de forma recursiva",
"unfoldAction.label": "Desplegar",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Desplegar Todas las Regiones"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Color del control plegable en el medianil del editor.",
"foldBackgroundBackground": "Color de fondo detrás de los rangos plegados. El color no debe ser opaco para no ocultar las decoraciones subyacentes.",
"foldingCollapsedIcon": "Icono de rangos contraídos en el margen de glifo del editor.",
"foldingExpandedIcon": "Icono de rangos expandidos en el margen de glifo del editor."
"foldingExpandedIcon": "Icono de rangos expandidos en el margen de glifo del editor.",
"foldingManualCollapedIcon": "Icono de intervalos contraídos manualmente en el margen del glifo del editor.",
"foldingManualExpandedIcon": "Icono de intervalos expandidos manualmente en el margen del glifo del editor."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Acercarse a la tipografía del editor",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Cargando...",
"stopped rendering": "Representación en pausa durante una línea larga por motivos de rendimiento. Esto se puede configurar mediante \"editor.stopRenderingLineAfter\".",
"too many characters": "Por motivos de rendimiento, la tokenización se omite con filas largas. Esta opción se puede configurar con \"editor.maxTokenizationLineLength\"."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Ver el problema"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Cambiar tamaño de visualización de tabulación",
"configuredTabSize": "Tamaño de tabulación configurado",
"currentTabSize": "Tamaño de tabulación actual",
"defaultTabSize": "Tamaño de tabulación predeterminado",
"detectIndentation": "Detectar sangría del contenido",
"editor.reindentlines": "Volver a aplicar sangría a líneas",
"editor.reindentselectedlines": "Volver a aplicar sangría a líneas seleccionadas",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd + clic"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Aceptar",
"acceptWord": "Aceptar palabra",
"action.inlineSuggest.accept": "Aceptar la sugerencia insertada",
"action.inlineSuggest.acceptNextWord": "Aceptar la siguiente palabra de sugerencia insertada",
"action.inlineSuggest.alwaysShowToolbar": "Mostrar siempre la barra de herramientas",
"action.inlineSuggest.hide": "Ocultar la sugerencia insertada",
"action.inlineSuggest.showNext": "Mostrar sugerencia alineada siguiente",
"action.inlineSuggest.showPrevious": "Mostrar sugerencia alineada anterior",
"action.inlineSuggest.trigger": "Desencadenar sugerencia alineada",
"action.inlineSuggest.undo": "Deshacer Aceptar palabra",
"alwaysShowInlineSuggestionToolbar": "Indica si la barra de herramientas de sugerencias insertada debe estar siempre visible",
"canUndoInlineSuggestion": "Si deshacer desharía una sugerencia insertada",
"inlineSuggestionHasIndentation": "Si la sugerencia alineada comienza con un espacio en blanco",
"inlineSuggestionHasIndentationLessThanTabSize": "Si la sugerencia insertada comienza con un espacio en blanco menor que lo que se insertaría mediante tabulación",
"inlineSuggestionVisible": "Si una sugerencia alineada está visible"
"inlineSuggestionVisible": "Si una sugerencia alineada está visible",
"undoAcceptWord": "Deshacer Aceptar palabra"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Sugerencia:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Siguiente",
"parameterHintsNextIcon": "Icono para mostrar la sugerencia de parámetro siguiente.",
"parameterHintsPreviousIcon": "Icono para mostrar la sugerencia de parámetro anterior.",
"previous": "Anterior"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Reemplazar con el valor siguiente",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Selección duplicada",
"editor.transformToCamelcase": "Transformar a mayúsculas y minúsculas Camel",
"editor.transformToKebabcase": "Transformar en caso Kebab",
"editor.transformToLowercase": "Transformar a minúsculas",
"editor.transformToSnakecase": "Transformar en Snake Case",
"editor.transformToTitlecase": "Transformar en Title Case",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Ejecutar el comando {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "No se puede editar en un editor de sólo lectura",
"messageVisible": "Indica si el editor muestra actualmente un mensaje insertado"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Mover última selección hasta la anterior coincidencia de búsqueda",
"mutlicursor.addCursorsToBottom": "Añadir cursores a la parte inferior",
"mutlicursor.addCursorsToTop": "Añadir cursores a la parte superior",
"mutlicursor.focusNextCursor": "Enfocar el siguiente cursor",
"mutlicursor.focusNextCursor.description": "Centra el cursor siguiente",
"mutlicursor.focusPreviousCursor": "Enfocar cursor anterior",
"mutlicursor.focusPreviousCursor.description": "Centra el cursor anterior",
"mutlicursor.insertAbove": "Agregar cursor arriba",
"mutlicursor.insertAtEndOfEachLineSelected": "Añadir cursores a finales de línea",
"mutlicursor.insertBelow": "Agregar cursor debajo",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Color de fondo del margen en el editor de vista de inspección.",
"peekViewEditorMatchHighlight": "Buscar coincidencia del color de resultado del editor de vista de inspección.",
"peekViewEditorMatchHighlightBorder": "Hacer coincidir el borde resaltado en el editor de vista previa.",
"peekViewEditorStickScrollBackground": "Color de fondo del desplazamiento permanente en el editor de vista de inspección.",
"peekViewResultsBackground": "Color de fondo de la lista de resultados de vista de inspección.",
"peekViewResultsFileForeground": "Color de primer plano de los archivos de inspección en la lista de resultados.",
"peekViewResultsMatchForeground": "Color de primer plano de los nodos de inspección en la lista de resultados.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "parámetros de tipo ({0})",
"variable": "variables ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "No se puede editar en un editor de sólo lectura",
"editor.simple.readonly": "No se puede editar en la entrada de solo lectura"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "Nombre cambiado correctamente de '{0}' a '{1}'. Resumen: {2}",
"enablePreview": "Activar/desactivar la capacidad de previsualizar los cambios antes de cambiar el nombre",
"label": "Cambiando el nombre de \"{0}\"",
"label": "Cambiando el nombre de '{0}' a '{1}'",
"no result": "No hay ningún resultado.",
"quotableLabel": "Cambiar el nombre de {0}",
"quotableLabel": "Cambiar el nombre de {0} a {1}",
"rename.failed": "No se pudo cambiar el nombre de las ediciones de cálculo",
"rename.failedApply": "No se pudo cambiar el nombre a las ediciones de aplicación",
"rename.label": "Cambiar el nombre del símbolo",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Indica si hay una tabulación siguiente cuando se está en modo de fragmentos de código.",
"hasPrevTabstop": "Si hay una tabulación anterior cuando se está en modo de fragmentos de código.",
"inSnippetMode": "Indica si el editor actual está en modo de fragmentos de código."
"inSnippetMode": "Indica si el editor actual está en modo de fragmentos de código.",
"next": "Ir al marcador de posición siguiente..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Abril",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Miércoles",
"WednesdayShort": "Mié"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Desplazamiento permanente",
"mitoggleStickyScroll": "&&Alternar desplazamiento permanente",
"stickyScroll": "Desplazamiento permanente",
"toggleStickyScroll": "Alternar desplazamiento permanente"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Indica si se insertan sugerencias al presionar Entrar.",
"suggestWidgetDetailsVisible": "Indica si los detalles de las sugerencias están visibles.",
"suggestWidgetHasSelection": "Si alguna sugerencia tiene el foco",
"suggestWidgetMultipleSuggestions": "Indica si hay varias sugerencias para elegir.",
"suggestionCanResolve": "Indica si la sugerencia actual admite la resolución de más detalles.",
"suggestionHasInsertAndReplaceRange": "Indica si la sugerencia actual tiene el comportamiento de inserción y reemplazo.",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Icono para obtener más información en el widget de sugerencias."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Color de primer plano de los símbolos de matriz. Estos símbolos aparecen en el contorno, la ruta de navegación y el widget de sugerencias.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "Este archivo \"{0}\" contiene uno o más caracteres de terminación de línea inusuales, como el separador de línea (LS) o el separador de párrafo (PS).\r\n\r\nSe recomienda eliminarlos del archivo. Esto puede configurarse mediante \"editor.unusualLineTerminators\".",
"unusualLineTerminators.fix": "Quitar terminadores de línea inusuales",
"unusualLineTerminators.fix": "&&Quitar terminadores de línea inusuales",
"unusualLineTerminators.ignore": "Omitir",
"unusualLineTerminators.message": "Se han detectado terminadores de línea inusuales",
"unusualLineTerminators.title": "Terminadores de línea inusuales"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Color del marcador de regla general para destacados de símbolos. El color no debe ser opaco para no ocultar decoraciones subyacentes.",
"overviewRulerWordHighlightStrongForeground": "Color de marcador de regla general para destacados de símbolos de acceso de escritura. El color no debe ser opaco para no ocultar las decoraciones subyacentes.",
"overviewRulerWordHighlightTextForeground": "Color del marcador de regla de información general de una repetición textual de un símbolo. El color no debe ser opaco para no ocultar las decoraciones subyacentes.",
"wordHighlight": "Color de fondo de un símbolo durante el acceso de lectura, como la lectura de una variable. El color no debe ser opaco para no ocultar decoraciones subyacentes.",
"wordHighlight.next.label": "Ir al siguiente símbolo destacado",
"wordHighlight.previous.label": "Ir al símbolo destacado anterior",
"wordHighlight.trigger.label": "Desencadenar los símbolos destacados",
"wordHighlightBorder": "Color de fondo de un símbolo durante el acceso de lectura; por ejemplo, cuando se lee una variable.",
"wordHighlightStrong": "Color de fondo de un símbolo durante el acceso de escritura, como escribir en una variable. El color no debe ser opaco para no ocultar las decoraciones subyacentes.",
"wordHighlightStrongBorder": "Color de fondo de un símbolo durante el acceso de escritura; por ejemplo, cuando se escribe una variable."
"wordHighlightStrongBorder": "Color de fondo de un símbolo durante el acceso de escritura; por ejemplo, cuando se escribe una variable.",
"wordHighlightText": "Color de fondo de la presencia textual para un símbolo. Para evitar ocultar cualquier decoración subyacente, el color no debe ser opaco.",
"wordHighlightTextBorder": "Color de borde de una repetición textual de un símbolo."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Ir al siguiente símbolo destacado",
"wordHighlight.previous.label": "Ir al símbolo destacado anterior",
"wordHighlight.trigger.label": "Desencadenar los símbolos destacados"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Eliminar palabra"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Desarrollador",
"help": "Ayuda",
"preferences": "Preferencias",
"test": "Probar",
"view": "Ver"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Ocultar",
"resetThisMenu": "Menú Restablecer"
},
"vs/platform/actions/common/menuService": {
"hide.label": "Ocultar \"{0}\""
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Widget de acción",
"customQuickFixWidget.labels": "{0}, Motivo de deshabilitación: {1}",
"label": "{0} para aplicar",
"label-preview": "{0} para aplicar, {1} para previsualizar"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Aceptar la acción seleccionada",
"codeActionMenuVisible": "Si la lista de widgets de acción es visible",
"hideCodeActionWidget.title": "Ocultar el widget de acción",
"previewSelected.title": "Vista previa de la acción seleccionada",
"selectNextCodeAction.title": "Seleccione la siguiente acción",
"selectPrevCodeAction.title": "Seleccione la acción anterior"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Línea de diferencia eliminada",
"audioCues.diffLineInserted": "Línea de diferencia insertada",
"audioCues.diffLineModified": "Línea de diferencia modificada",
"audioCues.lineHasBreakpoint.name": "Punto de interrupción en la línea",
"audioCues.lineHasError.name": "Error en la línea",
"audioCues.lineHasFoldedArea.name": "Área doblada en la línea",
"audioCues.lineHasInlineSuggestion.name": "Sugerencia insertada en la línea",
"audioCues.lineHasWarning.name": "Advertencia en la línea",
"audioCues.noInlayHints": "No hay sugerencias de incrustación en la línea",
"audioCues.notebookCellCompleted": "Celda del bloc de notas completada",
"audioCues.notebookCellFailed": "Error en la celda del bloc de notas",
"audioCues.onDebugBreak.name": "Depurador detenido en el punto de interrupción",
"audioCues.taskCompleted": "Tarea completada.",
"audioCues.taskFailed": "Error en la tarea",
"audioCues.terminalBell": "Campana de terminal",
"audioCues.terminalCommandFailed": "Error del comando de terminal",
"audioCues.terminalQuickFix.name": "Corrección rápida del terminal"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "No se puede registrar \"{0}\". La directiva asociada {1} ya está registrada con {2}.",
"config.property.duplicate": "No se puede registrar \"{0}\". Esta propiedad ya está registrada.",
"config.property.empty": "No se puede registrar una propiedad vacía.",
"config.property.languageDefault": "No se puede registrar \"{0}\". Coincide con el patrón de propiedad '\\\\[.*\\\\]$' para describir la configuración del editor específica del lenguaje. Utilice la contribución \"configurationDefaults\".",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Si el sistema operativo es Linux",
"isMac": "Si el sistema operativo es macOS",
"isMacNative": "Si el sistema operativo es macOS en una plataforma que no es de explorador",
"isMobile": "Si la plataforma es un explorador web móvil",
"isWeb": "Si la plataforma es un explorador web",
"isWindows": "Si el sistema operativo es Windows"
"isWindows": "Si el sistema operativo es Windows",
"productQualityType": "Tipo de calidad de VS Code"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Cancelar",
"moreFile": "...1 archivo más que no se muestra",
"moreFiles": "...{0} archivos más que no se muestran"
"moreFiles": "...{0} archivos más que no se muestran",
"okButton": "&&Aceptar",
"yesButton": "&&Sí"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "El archivo es demasiado grande para abrirlo como editor sin título. Cárguelo primero en el explorador de archivos e inténtelo de nuevo."
},
"vs/platform/files/common/files": {
"sizeB": "{0} B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Multiplicador de la velocidad de desplazamiento al presionar \"Alt\".",
"Mouse Wheel Scroll Sensitivity": "Se usará un multiplicador en los eventos de desplazamiento de la rueda del mouse \"deltaX\" y \"deltaY\". ",
"automatic keyboard navigation setting": "Controla si la navegación del teclado en listas y árboles se activa automáticamente simplemente escribiendo. Si se establece en \"false\", la navegación con el teclado solo se activa al ejecutar el comando \"list.toggleKeyboardNavigation\", para el cual puede asignar un método abreviado de teclado.",
"defaultFindMatchTypeSettingKey": "Controla el tipo de coincidencia que se usa al buscar listas y árboles en el área de trabajo.",
"defaultFindMatchTypeSettingKey.contiguous": "Use coincidencias contiguas al buscar.",
"defaultFindMatchTypeSettingKey.fuzzy": "Usar coincidencias aproximadas al buscar.",
"defaultFindModeSettingKey": "Controla el modo de búsqueda predeterminado para listas y árboles en el área de trabajo.",
"defaultFindModeSettingKey.filter": "Filtre elementos al buscar.",
"defaultFindModeSettingKey.highlight": "Resalta elementos al buscar. Navegar más arriba o abajo pasará solo por los elementos resaltados.",
"expand mode": "Controla cómo se expanden las carpetas de árbol al hacer clic en sus nombres. Tenga en cuenta que algunos árboles y listas pueden optar por omitir esta configuración si no es aplicable.",
"horizontalScrolling setting": "Controla si las listas y los árboles admiten el desplazamiento horizontal en el área de trabajo. Advertencia: La activación de esta configuración repercute en el rendimiento.",
"keyboardNavigationSettingKey": "Controla el estilo de navegación del teclado para listas y árboles en el área de trabajo. Puede ser simple, resaltar y filtrar.",
"keyboardNavigationSettingKey.filter": "La navegación mediante el teclado de filtro filtrará y ocultará todos los elementos que no coincidan con la entrada del teclado.",
"keyboardNavigationSettingKey.highlight": "Destacar la navegación del teclado resalta los elementos que coinciden con la entrada del teclado. Más arriba y abajo la navegación atravesará solo los elementos destacados.",
"keyboardNavigationSettingKey.simple": "La navegación simple del teclado se centra en elementos que coinciden con la entrada del teclado. El emparejamiento se hace solo en prefijos.",
"keyboardNavigationSettingKeyDeprecated": "Use \"workbench.list.defaultFindMode\" y \"workbench.list.typeNavigationMode\" en su lugar.",
"list smoothScrolling setting": "Controla si las listas y los árboles tienen un desplazamiento suave.",
"list.scrollByPage": "Controla si los clics en la barra de desplazamiento se desplazan página por página.",
"multiSelectModifier": "El modificador que se utilizará para agregar un elemento en los árboles y listas para una selección múltiple con el ratón (por ejemplo en el explorador, abiertos editores y vista de scm). Los gestos de ratón 'Abrir hacia' - si están soportados - se adaptarán de forma tal que no tenga conflicto con el modificador múltiple.",
"multiSelectModifier.alt": "Se asigna a \"Alt\" en Windows y Linux y a \"Opción\" en macOS.",
"multiSelectModifier.ctrlCmd": "Se asigna a \"Control\" en Windows y Linux y a \"Comando\" en macOS.",
"openModeModifier": "Controla cómo abrir elementos en los árboles y las listas mediante el mouse (si se admite). Tenga en cuenta que algunos árboles y listas pueden optar por ignorar esta configuración si no es aplicable.",
"render tree indent guides": "Controla si el árbol debe representar guías de sangría.",
"tree indent setting": "Controla la sangría de árbol en píxeles.",
"typeNavigationMode": "Controla el funcionamiento de la navegación por tipos en listas y árboles del área de trabajo. Cuando se establece en \"trigger\", la navegación por tipos comienza una vez que se ejecuta el comando \"list.triggerTypeNavigation\".",
"workbenchConfigurationTitle": "Área de trabajo"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Advertencia"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "El comando \"{0}\" dio lugar a un error ({1})",
"canNotRun": "El comando \"{0}\" ha dado lugar a un error",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "usados habitualmente",
"morecCommands": "otros comandos",
"recentlyUsed": "usado recientemente"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "comandos del editor",
"globalCommands": "comandos globales",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Personalizado",
"inputModeEntry": "Presione \"Entrar\" para confirmar su entrada o \"Esc\" para cancelar",
"inputModeEntryDescription": "{0} (Presione \"Entrar\" para confirmar o \"Esc\" para cancelar)",
"ok": "Aceptar",
"quickInput.back": "Atrás",
"quickInput.backWithKeybinding": "Atrás ({0})",
"quickInput.checkAll": "Activar o desactivar todas las casillas",
"quickInput.countSelected": "{0} seleccionados",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} resultados",
"quickInputBox.ariaLabel": "Escriba para restringir los resultados."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Entrada rápida"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Haga clic en para ejecutar el comando \"{0}\""
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Un borde adicional alrededor de los elementos activos para separarlos unos de otros y así mejorar el contraste.",
"activeLinkForeground": "Color de los vínculos activos.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Color de fondo de los elementos de ruta de navegación",
"breadcrumbsFocusForeground": "Color de los elementos de ruta de navegación que reciben el foco.",
"breadcrumbsSelectedBackground": "Color de fondo del selector de elementos de ruta de navegación.",
"breadcrumbsSelectedForegound": "Color de los elementos de ruta de navegación seleccionados.",
"breadcrumbsSelectedForeground": "Color de los elementos de ruta de navegación seleccionados.",
"buttonBackground": "Color de fondo del botón.",
"buttonBorder": "Color del borde del botón",
"buttonForeground": "Color de primer plano del botón.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Color de fondo del botón secundario.",
"buttonSecondaryForeground": "Color de primer plano del botón secundario.",
"buttonSecondaryHoverBackground": "Color de fondo del botón secundario al mantener el mouse.",
"buttonSeparator": "Color del separador de botones.",
"chartsBlue": "Color azul que se usa en las visualizaciones de gráficos.",
"chartsForeground": "Color de primer plano que se usa en los gráficos.",
"chartsGreen": "Color verde que se usa en las visualizaciones de gráficos.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Color de fondo de la casilla de verificación del widget.",
"checkbox.border": "Color del borde del widget de la casilla de verificación.",
"checkbox.foreground": "Color de primer plano del widget de la casilla de verificación.",
"checkbox.select.background": "Color de fondo del widget de la casilla cuando se selecciona el elemento en el que se encuentra.",
"checkbox.select.border": "Color de borde del widget de la casilla cuando se selecciona el elemento en el que se encuentra.",
"contrastBorder": "Un borde adicional alrededor de los elementos para separarlos unos de otros y así mejorar el contraste.",
"descriptionForeground": "Color de primer plano para el texto descriptivo que proporciona información adicional, por ejemplo para una etiqueta.",
"diffDiagonalFill": "Color de relleno diagonal del editor de diferencias. El relleno diagonal se usa en las vistas de diferencias en paralelo.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Color de fondo del margen donde se quitaron las líneas.",
"diffEditorRemovedLines": "Color de fondo de las líneas que se quitaron. El color no debe ser opaco para no ocultar las decoraciones subyacentes.",
"diffEditorRemovedOutline": "Color de contorno para el texto quitado.",
"disabledForeground": "Primer plano general de los elementos deshabilitados. Este color solo se usa si un componente no lo reemplaza.",
"dropdownBackground": "Fondo de lista desplegable.",
"dropdownBorder": "Borde de lista desplegable.",
"dropdownForeground": "Primer plano de lista desplegable.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Color del texto seleccionado para alto contraste.",
"editorSelectionHighlight": "Color en las regiones con el mismo contenido que la selección. El color no debe ser opaco para no ocultar decoraciones subyacentes.",
"editorSelectionHighlightBorder": "Color de borde de las regiones con el mismo contenido que la selección.",
"editorStickyScrollBackground": "Color de fondo de desplazamiento permanente para el editor",
"editorStickyScrollHoverBackground": "Desplazamiento permanente al mantener el mouse sobre el color de fondo del editor",
"editorWarning.background": "Color de fondo del texto de advertencia del editor. El color no debe ser opaco para no ocultar las decoraciones subyacentes.",
"editorWarning.foreground": "Color de primer plano de squigglies de advertencia en el editor.",
"editorWidgetBackground": "Color de fondo del editor de widgets como buscar/reemplazar",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Color de fondo del widget de filtro de tipo en listas y árboles.",
"listFilterWidgetNoMatchesOutline": "Color de contorno del widget de filtro de tipo en listas y árboles, cuando no hay coincidencias.",
"listFilterWidgetOutline": "Color de contorno del widget de filtro de tipo en listas y árboles.",
"listFilterWidgetShadow": "Color del sombreado del widget de filtrado de escritura en listas y árboles.",
"listFocusAndSelectionOutline": "Color de contorno de la lista o el árbol del elemento con el foco cuando la lista o el árbol están activos y seleccionados. Una lista o un árbol tienen el foco del teclado cuando están activos, pero no cuando están inactivos.",
"listFocusBackground": "Color de fondo de la lista o el árbol del elemento con el foco cuando la lista o el árbol están activos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.",
"listFocusForeground": "Color de primer plano de la lista o el árbol del elemento con el foco cuando la lista o el árbol están activos. Una lista o un árbol tienen el foco del teclado cuando están activos, cuando están inactivos no.",
"listFocusHighlightForeground": "Color de primer plano de la lista o árbol de los elementos coincidentes en los elementos enfocados activamente cuando se busca dentro de la lista o árbol.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Fondo de la barra de herramientas al mantener el mouse sobre las acciones",
"toolbarHoverBackground": "El fondo de la barra de herramientas se perfila al pasar por encima de las acciones con el mouse.",
"toolbarHoverOutline": "La barra de herramientas se perfila al pasar por encima de las acciones con el mouse.",
"treeInactiveIndentGuidesStroke": "Color de trazo de árbol para las guías de sangría que no están activas.",
"treeIndentGuidesStroke": "Color de trazo de árbol para las guías de sangría.",
"warningBorder": "Color del borde de los cuadros de advertencia en el editor.",
"widgetBorder": "Color de borde de los widgets dentro del editor, como buscar/reemplazar",
"widgetShadow": "Color de sombra de los widgets dentro del editor, como buscar/reemplazar"
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Icono de la acción de cierre en los widgets."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Cancelar",
"cannotResourceRedoDueToInProgressUndoRedo": "No se pudo rehacer \"{0}\" porque ya hay una operación de deshacer o rehacer en ejecución.",
"cannotResourceUndoDueToInProgressUndoRedo": "No se pudo deshacer \"{0}\" porque ya hay una operación de deshacer o rehacer en ejecución.",
"cannotWorkspaceRedo": "No se pudo rehacer \"{0}\" en todos los archivos. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "No se pudo deshacer \"{0}\" en todos los archivos porque ya hay una operación de deshacer o rehacer en ejecución en {1}",
"confirmDifferentSource": "¿Quiere deshacer \"{0}\"?",
"confirmDifferentSource.no": "No",
"confirmDifferentSource.yes": "Sí",
"confirmDifferentSource.yes": "&&Sí",
"confirmWorkspace": "¿Desea deshacer \"{0}\" en todos los archivos?",
"externalRemoval": "Se han cerrado los siguientes archivos y se han modificado en el disco: {0}.",
"noParallelUniverses": "Los siguientes archivos se han modificado de forma incompatible: {0}.",
"nok": "Deshacer este archivo",
"ok": "Deshacer en {0} archivos"
"nok": "Deshacer este &&archivo",
"ok": "&&Deshacer en {0} archivos"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Área de trabajo de código"

406
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/fr.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Plus d'actions..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Fermer la boîte de dialogue",
"dialogErrorMessage": "Erreur",
"dialogInfoMessage": "Infos",
"dialogPendingMessage": "En cours",
"dialogWarningMessage": "Avertissement",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Plus d’actions..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "entrée"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Respecter la casse",
"regexDescription": "Utiliser une expression régulière",
"wordsDescription": "Mot entier"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "entrée",
"label.preserveCaseToggle": "Préserver la casse"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Indépendant"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Zone de sélection"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Plus d'actions..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Effacer",
"disable filter on type": "Désactiver le filtre sur le type",
"empty": "Aucun élément",
"enable filter on type": "Activer le filtre sur le type",
"found": "{0} éléments sur {1} correspondants"
"close": "Fermer",
"filter": "Filtrer",
"fuzzySearch": "Correspondance approximative",
"not found": "Aucun élément trouvé.",
"type to filter": "Type à filtrer",
"type to search": "Entrer le texte à rechercher"
},
"vs/base/common/actions": {
"submenu.empty": "(vide)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Personnalisé",
"inputModeEntry": "Appuyez sur 'Entrée' pour confirmer votre saisie, ou sur 'Échap' pour l'annuler",
"inputModeEntryDescription": "{0} (Appuyez sur 'Entrée' pour confirmer ou sur 'Échap' pour annuler)",
"ok": "OK",
"quickInput.back": "Précédent",
"quickInput.backWithKeybinding": "Précédent ({0})",
"quickInput.countSelected": "{0} Sélectionnés",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} résultats",
"quickInputBox.ariaLabel": "Taper pour affiner les résultats."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Entrée rapide"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "L'éditeur n'est pas accessible pour le moment. Appuyez sur {0} pour voir les options.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Annuler"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "Le nombre de curseurs a été limité à {0}."
"cursors.maximum": "Le nombre de curseurs a été limité à {0}. Envisagez d’utiliser [rechercher et remplacer](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) pour les modifications plus importantes ou augmentez la limite du nombre de curseurs multiples du paramètre.",
"goToSetting": "Augmenter la limite de curseurs multiples"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " utiliser Maj + F7 pour parcourir les modifications",
"diff.tooLarge": "Impossible de comparer les fichiers car l'un d'eux est trop volumineux.",
"diffInsertIcon": "Élément décoratif de ligne pour les insertions dans l'éditeur de différences.",
"diffRemoveIcon": "Élément décoratif de ligne pour les suppressions dans l'éditeur de différences."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Contrôle si l'éditeur affiche CodeLens.",
"detectIndentation": "Contrôle si '#editor.tabSize#' et '#editor.insertSpaces#' sont automatiquement détectés lors de l’ouverture d’un fichier en fonction de son contenu.",
"detectIndentation": "Contrôle si {0} et {1} sont automatiquement détectés lors de l’ouverture d’un fichier en fonction de son contenu.",
"diffAlgorithm.experimental": "Utilise un algorithme de comparaison expérimental.",
"diffAlgorithm.smart": "Utilise l’algorithme de comparaison par défaut.",
"editor.experimental.asyncTokenization": "Contrôle si la création de jetons doit se produire de manière asynchrone sur un worker web.",
"editorConfigurationTitle": "Éditeur",
"ignoreTrimWhitespace": "Quand il est activé, l'éditeur de différences ignore les changements d'espace blanc de début ou de fin.",
"insertSpaces": "Espaces insérés quand vous appuyez sur la touche Tab. Ce paramètre est remplacé en fonction du contenu du fichier quand '#editor.detectIndentation#' est activé.",
"indentSize": "Nombre d’espaces utilisés pour la mise en retrait ou `\"tabSize\"` pour utiliser la valeur de `#editor.tabSize#`. Ce paramètre est remplacé en fonction du contenu du fichier quand `#editor.detectIndentation#` est activé.",
"insertSpaces": "Espaces insérés quand vous appuyez sur la touche Tab. Ce paramètre est remplacé en fonction du contenu du fichier quand {0} est activé.",
"largeFileOptimizations": "Traitement spécial des fichiers volumineux pour désactiver certaines fonctionnalités utilisant beaucoup de mémoire.",
"maxComputationTime": "Délai d'expiration en millisecondes avant annulation du calcul de diff. Utilisez 0 pour supprimer le délai d'expiration.",
"maxFileSize": "Taille de fichier maximale en Mo pour laquelle calculer les différences. Utilisez 0 pour ne pas avoir de limite.",
"maxTokenizationLineLength": "Les lignes plus longues que cette valeur ne sont pas tokenisées pour des raisons de performances",
"renderIndicators": "Contrôle si l'éditeur de différences affiche les indicateurs +/- pour les changements ajoutés/supprimés .",
"renderMarginRevertIcon": "Lorsqu’il est activé, l’éditeur de différences affiche des flèches dans sa marge de glyphe pour rétablir les modifications.",
"schema.brackets": "Définit les symboles de type crochet qui augmentent ou diminuent le retrait.",
"schema.closeBracket": "Séquence de chaînes ou de caractères de crochets fermants.",
"schema.colorizedBracketPairs": "Définit les paires de crochets qui sont colorisées par leur niveau d’imbrication si la colorisation des paires de crochets est activée.",
@ -139,15 +160,15 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.false": "Coloration sémantique désactivée pour tous les thèmes de couleur.",
"semanticHighlighting.true": "Coloration sémantique activée pour tous les thèmes de couleur.",
"sideBySide": "Contrôle si l'éditeur de différences affiche les différences en mode côte à côte ou inline.",
"stablePeek": "Garder les éditeurs d'aperçu ouverts même si l'utilisateur double-clique sur son contenu ou appuie sur la touche Échap. ",
"tabSize": "Le nombre d'espaces auxquels une tabulation est égale. Ce paramètre est substitué basé sur le contenu du fichier lorsque `#editor.detectIndentation#` est à 'on'.",
"stablePeek": "Maintenir les éditeurs d'aperçu ouverts même si l'utilisateur double-clique sur son contenu ou appuie sur la touche Échap.",
"tabSize": "Le nombre d’espaces auxquels une tabulation est égale. Ce paramètre est substitué basé sur le contenu du fichier lorsque {0} est activé.",
"trimAutoWhitespace": "Supprimer l'espace blanc de fin inséré automatiquement.",
"wordBasedSuggestions": "Contrôle si la saisie semi-automatique doit être calculée en fonction des mots présents dans le document.",
"wordBasedSuggestionsMode": "Contrôle la façon dont sont calculées les complétions basées sur des mots dans les documents.",
"wordBasedSuggestionsMode.allDocuments": "Suggère des mots dans tous les documents ouverts.",
"wordBasedSuggestionsMode.currentDocument": "Suggère uniquement des mots dans le document actif.",
"wordBasedSuggestionsMode.matchingDocuments": "Suggère des mots dans tous les documents ouverts du même langage.",
"wordWrap.inherit": "Le retour automatique à la ligne dépend du paramètre '#editor.wordWrap#'.",
"wordWrap.inherit": "Le retour automatique à la ligne dépend du paramètre {0}.",
"wordWrap.off": "Le retour automatique à la ligne n'est jamais effectué.",
"wordWrap.on": "Le retour automatique à la ligne s'effectue en fonction de la largeur de la fenêtre d'affichage."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Contrôle si les suggestions sont acceptées après appui sur 'Entrée', en plus de 'Tab'. Permet d’éviter toute ambiguïté entre l’insertion de nouvelles lignes et l'acceptation de suggestions.",
"acceptSuggestionOnEnterSmart": "Accepter uniquement une suggestion avec 'Entrée' quand elle effectue une modification textuelle.",
"accessibilityPageSize": "Contrôle le nombre de lignes de l’éditeur qu’un lecteur d’écran peut lire en une seule fois. Quand nous détectons un lecteur d’écran, nous définissons automatiquement la valeur par défaut à 500. Attention : Les valeurs supérieures à la valeur par défaut peuvent avoir un impact important sur les performances.",
"accessibilitySupport": "Contrôle si l'éditeur doit s'exécuter dans un mode optimisé pour les lecteurs d'écran. Si la valeur est on, le retour automatique à la ligne est désactivé.",
"accessibilitySupport.auto": "L'éditeur utilise les API de la plateforme pour détecter si un lecteur d'écran est attaché.",
"accessibilitySupport.off": "L'éditeur n'est jamais optimisé pour une utilisation avec un lecteur d'écran.",
"accessibilitySupport.on": "L'éditeur est optimisé en permanence pour les lecteurs d'écran. Le retour automatique à la ligne est désactivé.",
"accessibilitySupport": "Contrôle si l’interface utilisateur doit s’exécuter dans un mode où elle est optimisée pour les lecteurs d’écran.",
"accessibilitySupport.auto": "Utiliser les API de la plateforme pour détecter si un lecteur d'écran est attaché",
"accessibilitySupport.off": "Supposer qu’un lecteur d’écran n’est pas attaché",
"accessibilitySupport.on": "Optimiser pour l’utilisation avec un lecteur d’écran",
"alternativeDeclarationCommand": "ID de commande alternatif exécuté quand le résultat de 'Atteindre la déclaration' est l'emplacement actuel.",
"alternativeDefinitionCommand": "ID de commande alternatif exécuté quand le résultat de 'Atteindre la définition' est l'emplacement actuel.",
"alternativeImplementationCommand": "ID de commande alternatif exécuté quand le résultat de 'Atteindre l'implémentation' est l'emplacement actuel.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Contrôle si l’éditeur doit fermer automatiquement les guillemets après que l’utilisateur ajoute un guillemet ouvrant.",
"autoIndent": "Contrôle si l'éditeur doit ajuster automatiquement le retrait quand les utilisateurs tapent, collent, déplacent ou mettent en retrait des lignes.",
"autoSurround": "Contrôle si l'éditeur doit automatiquement entourer les sélections quand l'utilisateur tape des guillemets ou des crochets.",
"bracketPairColorization.enabled": "Contrôle si la coloration de la paire de crochets est activée ou non. Utilisez « workbench.colorCustomizations » pour remplacer les couleurs de surbrillance de crochets.",
"bracketPairColorization.enabled": "Contrôle si la colorisation des paires de crochets est activée ou non. Utilisez {0} pour remplacer les couleurs de surbrillance des crochets.",
"bracketPairColorization.independentColorPoolPerBracketType": "Contrôle si chaque type de crochet possède son propre pool de couleurs indépendant.",
"codeActions": "Active l’ampoule d’action de code dans l’éditeur.",
"codeLens": "Contrôle si l'éditeur affiche CodeLens.",
"codeLensFontFamily": "Contrôle la famille de polices pour CodeLens.",
"codeLensFontSize": "Contrôle la taille de police en pixels pour CodeLens. Quand la valeur est '0', 90 % de '#editor.fontSize#' est utilisé.",
"codeLensFontSize": "Contrôle la taille de police en pixels pour CodeLens. Quand la valeur est 0, 90 % de '#editor.fontSize#' est utilisé.",
"colorDecorators": "Contrôle si l'éditeur doit afficher les éléments décoratifs de couleurs inline et le sélecteur de couleurs.",
"colorDecoratorsLimit": "Contrôle le nombre maximal d’éléments décoratifs de couleur qui peuvent être rendus simultanément dans un éditeur.",
"columnSelection": "Autoriser l'utilisation de la souris et des touches pour sélectionner des colonnes.",
"comments.ignoreEmptyLines": "Contrôle si les lignes vides doivent être ignorées avec des actions d'activation/de désactivation, d'ajout ou de suppression des commentaires de ligne.",
"comments.insertSpace": "Contrôle si un espace est inséré pour les commentaires.",
"copyWithSyntaxHighlighting": "Contrôle si la coloration syntaxique doit être copiée dans le presse-papiers.",
"cursorBlinking": "Contrôler le style d’animation du curseur.",
"cursorSmoothCaretAnimation": "Contrôle si l'animation du point d'insertion doit être activée.",
"cursorSmoothCaretAnimation.explicit": "L’animation de caret fluide est activée uniquement lorsque l’utilisateur déplace le curseur avec un mouvement explicite.",
"cursorSmoothCaretAnimation.off": "L’animation de caret fluide est désactivée.",
"cursorSmoothCaretAnimation.on": "L’animation de caret fluide est toujours activée.",
"cursorStyle": "Contrôle le style du curseur.",
"cursorSurroundingLines": "Contrôle le nombre minimal de lignes de début et de fin visibles autour du curseur. Également appelé 'scrollOff' ou 'scrollOffset' dans d'autres éditeurs.",
"cursorSurroundingLines": "Contrôle le nombre minimal de lignes de début (0 minimum) et de fin (1 minimum) visibles autour du curseur. Également appelé « scrollOff » ou « scrollOffset » dans d'autres éditeurs.",
"cursorSurroundingLinesStyle": "Contrôle quand 'cursorSurroundingLines' doit être appliqué.",
"cursorSurroundingLinesStyle.all": "'cursorSurroundingLines' est toujours appliqué.",
"cursorSurroundingLinesStyle.default": "'cursorSurroundingLines' est appliqué seulement s'il est déclenché via le clavier ou une API.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Contrôle si le geste de souris Accéder à la définition ouvre toujours le widget d'aperçu.",
"deprecated": "Ce paramètre est déprécié, veuillez utiliser des paramètres distincts comme 'editor.suggest.showKeywords' ou 'editor.suggest.showSnippets' à la place.",
"dragAndDrop": "Contrôle si l’éditeur autorise le déplacement de sélections par glisser-déplacer.",
"dropIntoEditor.enabled": "Contrôle si vous pouvez faire glisser et déposer un fichier dans un éditeur de texte en maintenant la touche Maj enfoncée (au lieu d’ouvrir le fichier dans un éditeur).",
"editor.autoClosingBrackets.beforeWhitespace": "Fermer automatiquement les parenthèses uniquement lorsque le curseur est à gauche de l’espace.",
"editor.autoClosingBrackets.languageDefined": "Utilisez les configurations de langage pour déterminer quand fermer automatiquement les parenthèses.",
"editor.autoClosingDelete.auto": "Supprimez les guillemets ou crochets fermants adjacents uniquement s'ils ont été insérés automatiquement.",
@ -219,9 +245,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.find.seedSearchStringFromSelection.never": "Ne lancez jamais la chaîne de recherche dans la sélection de l’éditeur.",
"editor.find.seedSearchStringFromSelection.selection": "Chaîne de recherche initiale uniquement dans la sélection de l’éditeur.",
"editor.gotoLocation.multiple.deprecated": "Ce paramètre est déprécié, utilisez des paramètres distincts comme 'editor.editor.gotoLocation.multipleDefinitions' ou 'editor.editor.gotoLocation.multipleImplementations' à la place.",
"editor.gotoLocation.multiple.goto": "Accéder au résultat principal et activer l'accès sans aperçu pour les autres",
"editor.gotoLocation.multiple.goto": "Accéder au résultat principal et activer l’accès sans aperçu pour les autres",
"editor.gotoLocation.multiple.gotoAndPeek": "Accéder au résultat principal et montrer un aperçu",
"editor.gotoLocation.multiple.peek": "Montrer l'aperçu des résultats (par défaut)",
"editor.gotoLocation.multiple.peek": "Montrer l’aperçu des résultats (par défaut)",
"editor.guides.bracketPairs": "Contrôle si les guides de la paire de crochets sont activés ou non.",
"editor.guides.bracketPairs.active": "Active les repères de paire de crochets uniquement pour la paire de crochets actifs.",
"editor.guides.bracketPairs.false": "Désactive les repères de paire de crochets.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Active les repères horizontaux en plus des repères de paire de crochets verticaux.",
"editor.guides.highlightActiveBracketPair": "Contrôle si l’éditeur doit mettre en surbrillance la paire de crochets actifs.",
"editor.guides.highlightActiveIndentation": "Contrôle si l’éditeur doit mettre en surbrillance le guide de mise en retrait actif.",
"editor.guides.highlightActiveIndentation.always": "Met en surbrillance le repère de retrait actif même si les repères de crochet sont mis en surbrillance.",
"editor.guides.highlightActiveIndentation.false": "Ne mettez pas en surbrillance le repère de retrait actif.",
"editor.guides.highlightActiveIndentation.true": "Met en surbrillance le guide de retrait actif.",
"editor.guides.indentation": "Contrôle si l’éditeur doit afficher les guides de mise en retrait.",
"editor.inlayHints.off": "Les indicateurs d’inlay sont désactivés.",
"editor.inlayHints.offUnlessPressed": "Les indicateurs d’inlay sont masqués par défaut et s’affichent lorsque vous maintenez {0}",
"editor.inlayHints.on": "Les indicateurs d’inlay sont activés.",
"editor.inlayHints.onUnlessPressed": "Les indicateurs d’inlay sont affichés par défaut et masqués lors de la conservation {0}",
"editor.stickyScroll": "Affiche les étendues actives imbriqués pendant le défilement en haut de l’éditeur.",
"editor.stickyScroll.": "Définit le nombre maximal de lignes rémanentes à afficher.",
"editor.suggest.matchOnWordStartOnly": "Quand le filtrage IntelliSense est activé, le premier caractère correspond à un début de mot, par exemple 'c' sur 'Console' ou 'WebContext', mais _not_ sur 'description'. Si désactivé, IntelliSense affiche plus de résultats, mais les trie toujours par qualité de correspondance.",
"editor.suggest.showClasss": "Si activé, IntelliSense montre des suggestions de type 'class'.",
"editor.suggest.showColors": "Si activé, IntelliSense montre des suggestions de type 'color'.",
"editor.suggest.showConstants": "Si activé, IntelliSense montre des suggestions de type 'constant'.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Si activé, IntelliSense montre des suggestions de type 'variable'.",
"editorViewAccessibleLabel": "Contenu de l'éditeur",
"emptySelectionClipboard": "Contrôle si la copie sans sélection permet de copier la ligne actuelle.",
"experimentalWhitespaceRendering": "Contrôle si les espaces blancs sont rendus avec une nouvelle méthode expérimentale.",
"experimentalWhitespaceRendering.font": "Utilisez une nouvelle méthode de rendu avec des caractères de police.",
"experimentalWhitespaceRendering.off": "Utilisez la méthode de rendu stable.",
"experimentalWhitespaceRendering.svg": "Utilisez une nouvelle méthode de rendu avec des SVG.",
"fastScrollSensitivity": "Multiplicateur de vitesse de défilement quand vous appuyez sur 'Alt'.",
"find.addExtraSpaceOnTop": "Contrôle si le widget Recherche doit ajouter des lignes supplémentaires en haut de l'éditeur. Quand la valeur est true, vous pouvez faire défiler au-delà de la première ligne si le widget Recherche est visible.",
"find.autoFindInSelection": "Contrôle la condition d'activation automatique de la recherche dans la sélection.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Active/désactive les ligatures de police (fonctionnalités de police 'calt' et 'liga'). Remplacez ceci par une chaîne pour contrôler de manière précise la propriété CSS 'font-feature-settings'.",
"fontLigaturesGeneral": "Configure les ligatures de police ou les fonctionnalités de police. Il peut s'agir d'une valeur booléenne permettant d'activer/de désactiver les ligatures, ou d'une chaîne correspondant à la valeur de la propriété CSS 'font-feature-settings'.",
"fontSize": "Contrôle la taille de police en pixels.",
"fontVariationSettings": "Propriété CSS 'font-variation-settings' explicite. Une valeur booléenne peut être passée à la place si une seule valeur doit traduire font-weight en font-variation-settings.",
"fontVariations": "Active/désactive la traduction de font-weight en font-variation-settings. Remplacez ce paramètre par une chaîne pour un contrôle affiné de la propriété CSS 'font-variation-settings'.",
"fontVariationsGeneral": "Configure les variations de la police. Il peut s’agir d’une valeur booléenne pour activer/désactiver la traduction de font-weight en font-variation-settings ou d’une chaîne pour la valeur de la propriété CSS 'font-variation-settings'.",
"fontWeight": "Contrôle l'épaisseur de police. Accepte les mots clés \"normal\" et \"bold\", ou les nombres compris entre 1 et 1 000.",
"fontWeightErrorMessage": "Seuls les mots clés \"normal\" et \"bold\", ou les nombres compris entre 1 et 1 000 sont autorisés.",
"formatOnPaste": "Détermine si l’éditeur doit automatiquement mettre en forme le contenu collé. Un formateur doit être disponible et être capable de mettre en forme une plage dans un document.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Contrôle si le pointage est affiché.",
"hover.sticky": "Contrôle si le pointage doit rester visible quand la souris est déplacée au-dessus.",
"inlayHints.enable": "Active les indicateurs inlay dans l’éditeur.",
"inlayHints.fontFamily": "Contrôle la famille de polices des indicateurs d’inlay dans l’éditeur. Lorsqu’il est défini sur vide, '#editor.fontFamily#' est utilisé.",
"inlayHints.fontSize": "Contrôle la taille de police des indicateurs d’inlay dans l’éditeur. La valeur par défaut de 90 % de « #editor.fontSize# » est utilisée lorsque la valeur configurée est inférieure à « 5 » ou supérieure à la taille de police de l’éditeur.",
"inlayHints.fontFamily": "Contrôle la famille de polices des indicateurs d’inlay dans l’éditeur. Lorsqu’il est défini sur vide, le {0} est utilisé.",
"inlayHints.fontSize": "Contrôle la taille de police des indicateurs d’inlay dans l’éditeur. Par défaut, le {0} est utilisé lorsque la valeur configurée est inférieure à {1} ou supérieure à la taille de police de l’éditeur.",
"inlayHints.padding": "Active le remplissage autour des indicateurs d’inlay dans l’éditeur.",
"inline": "Les suggestions rapides s’affichent sous forme de texte fantôme",
"inlineSuggest.enabled": "Contrôle si les suggestions en ligne doivent être affichées automatiquement dans l’éditeur.",
"inlineSuggest.showToolbar": "Contrôle quand afficher la barre d’outils de suggestion incluse.",
"inlineSuggest.showToolbar.always": "Afficher la barre d’outils de suggestion en ligne chaque fois qu’une suggestion inline est affichée.",
"inlineSuggest.showToolbar.onHover": "Afficher la barre d’outils de suggestion en ligne lorsque vous pointez sur une suggestion incluse.",
"letterSpacing": "Contrôle l'espacement des lettres en pixels.",
"lineHeight": "Contrôle la hauteur de ligne. \r\n - Utilisez 0 pour calculer automatiquement la hauteur de ligne à partir de la taille de police.\r\n : les valeurs comprises entre 0 et 8 sont utilisées comme multiplicateur avec la taille de police.\r\n : les valeurs supérieures ou égales à 8 seront utilisées comme valeurs effectives.",
"lineNumbers": "Contrôle l'affichage des numéros de ligne.",
@ -305,9 +352,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"lineNumbers.off": "Les numéros de ligne ne sont pas affichés.",
"lineNumbers.on": "Les numéros de ligne sont affichés en nombre absolu.",
"lineNumbers.relative": "Les numéros de ligne sont affichés sous la forme de distance en lignes à la position du curseur.",
"linkedEditing": "Contrôle si la modification liée est activée dans l'éditeur. En fonction du langage, les symboles associés, par exemple les balises HTML, sont mis à jour durant le processus de modification.",
"linkedEditing": "Contrôle si la modification liée est activée dans l’éditeur. En fonction du langage, les symboles associés, par exemple les balises HTML, sont mis à jour durant le processus de modification.",
"links": "Contrôle si l’éditeur doit détecter les liens et les rendre cliquables.",
"matchBrackets": "Mettez en surbrillance les crochets correspondants.",
"minimap.autohide": "Contrôle si la minimap est masquée automatiquement.",
"minimap.enabled": "Contrôle si la minimap est affichée.",
"minimap.maxColumn": "Limiter la largeur de la minimap pour afficher au plus un certain nombre de colonnes.",
"minimap.renderCharacters": "Afficher les caractères réels sur une ligne par opposition aux blocs de couleur.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "Le minimap a la même taille que le contenu de l'éditeur (défilement possible).",
"mouseWheelScrollSensitivity": "Un multiplicateur à utiliser sur les `deltaX` et `deltaY` des événements de défilement de roulette de souris.",
"mouseWheelZoom": "Faire un zoom sur la police de l'éditeur quand l'utilisateur fait tourner la roulette de la souris tout en maintenant la touche 'Ctrl' enfoncée.",
"multiCursorLimit": "Contrôle le nombre maximal de curseurs pouvant se trouver dans un éditeur actif à la fois.",
"multiCursorMergeOverlapping": "Fusionnez plusieurs curseurs quand ils se chevauchent.",
"multiCursorModifier": "The modifier to be used to add multiple cursors with the mouse. The Go to Definition and Open Link mouse gestures will adapt such that they do not conflict with the multicursor modifier. [Read more](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "Modificateur à utiliser pour ajouter plusieurs curseurs avec la souris. Les mouvements de la souris Atteindre la définition et Ouvrir le lien s’adaptent afin qu’ils ne soient pas en conflit avec le [modificateur multicurseur](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modificateur).",
"multiCursorModifier.alt": "Mappe vers 'Alt' dans Windows et Linux, et vers 'Option' dans macOS.",
"multiCursorModifier.ctrlCmd": "Mappe vers 'Contrôle' dans Windows et Linux, et vers 'Commande' dans macOS.",
"multiCursorPaste": "Contrôle le collage quand le nombre de lignes du texte collé correspond au nombre de curseurs.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Contrôle s'il faut mettre le focus sur l'éditeur inline ou sur l'arborescence dans le widget d'aperçu.",
"peekWidgetDefaultFocus.editor": "Placer le focus sur l'éditeur à l'ouverture de l'aperçu",
"peekWidgetDefaultFocus.tree": "Focus sur l'arborescence à l'ouverture de l'aperçu",
"quickSuggestions": "Contrôle si les suggestions doivent apparaître automatiquement pendant la saisie.",
"quickSuggestions": "Contrôle si les suggestions doivent s’afficher automatiquement lors de la saisie. Cela peut être contrôlé pour la saisie dans des commentaires, des chaînes et d’autres codes. Vous pouvez configurer la suggestion rapide pour qu’elle s’affiche sous forme de texte fantôme ou avec le widget de suggestion. Tenez également compte du paramètre '{0}' qui contrôle si des suggestions sont déclenchées par des caractères spéciaux.",
"quickSuggestions.comments": "Activez les suggestions rapides dans les commentaires.",
"quickSuggestions.other": "Activez les suggestions rapides en dehors des chaînes et des commentaires.",
"quickSuggestions.strings": "Activez les suggestions rapides dans les chaînes.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Contrôle quand afficher les contrôles de pliage sur la reliure.",
"showFoldingControls.always": "Affichez toujours les contrôles de pliage.",
"showFoldingControls.mouseover": "Affichez uniquement les contrôles de pliage quand la souris est au-dessus de la reliure.",
"showFoldingControls.never": "N’affichez jamais les contrôles de pliage et réduisez la taille de la marge.",
"showUnused": "Contrôle la disparition du code inutile.",
"smoothScrolling": "Contrôle si l'éditeur défile en utilisant une animation.",
"snippetSuggestions": "Contrôle si les extraits de code s'affichent en même temps que d'autres suggestions, ainsi que leur mode de tri.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Émule le comportement des tabulations pour la sélection quand des espaces sont utilisés à des fins de mise en retrait. La sélection respecte les taquets de tabulation.",
"suggest.filterGraceful": "Détermine si le filtre et le tri des suggestions doivent prendre en compte les fautes de frappes mineures.",
"suggest.insertMode": "Contrôle si les mots sont remplacés en cas d'acceptation de la saisie semi-automatique. Notez que cela dépend des extensions adhérant à cette fonctionnalité.",
"suggest.insertMode.always": "Toujours sélectionner une suggestion lors du déclenchement automatique d’IntelliSense.",
"suggest.insertMode.insert": "Insérez une suggestion sans remplacer le texte à droite du curseur.",
"suggest.insertMode.never": "Ne jamais sélectionner une suggestion lors du déclenchement automatique d’IntelliSense.",
"suggest.insertMode.replace": "Insérez une suggestion et remplacez le texte à droite du curseur.",
"suggest.insertMode.whenQuickSuggestion": "Sélectionnez une suggestion uniquement lors du déclenchement d’IntelliSense au cours de la frappe.",
"suggest.insertMode.whenTriggerCharacter": "Sélectionnez une suggestion uniquement lors du déclenchement d’IntelliSense à partir d’un caractère déclencheur.",
"suggest.localityBonus": "Contrôle si le tri favorise les mots qui apparaissent à proximité du curseur.",
"suggest.maxVisibleSuggestions.dep": "Ce paramètre est déprécié. Le widget de suggestion peut désormais être redimensionné.",
"suggest.preview": "Contrôle si la sortie de la suggestion doit être affichée en aperçu dans l’éditeur.",
"suggest.selectionMode": "Contrôle si une suggestion est sélectionnée lorsque le widget s’affiche. Notez que cela s’applique uniquement aux suggestions déclenchées automatiquement ('#editor.quickSuggestions#' et '#editor.suggestOnTriggerCharacters#') et qu’une suggestion est toujours sélectionnée lorsqu’elle est appelée explicitement, par exemple via 'Ctrl+Espace'.",
"suggest.shareSuggestSelections": "Contrôle si les sélections de suggestion mémorisées sont partagées entre plusieurs espaces de travail et fenêtres (nécessite '#editor.suggestSelection#').",
"suggest.showIcons": "Contrôle s'il faut montrer ou masquer les icônes dans les suggestions.",
"suggest.showInlineDetails": "Détermine si les détails du widget de suggestion sont inclus dans l'étiquette ou uniquement dans le widget de détails",
"suggest.showInlineDetails": "Détermine si les détails du widget de suggestion sont inclus dans l’étiquette ou uniquement dans le widget de détails.",
"suggest.showStatusBar": "Contrôle la visibilité de la barre d'état en bas du widget de suggestion.",
"suggest.snippetsPreventQuickSuggestions": "Contrôle si un extrait de code actif empêche les suggestions rapides.",
"suggestFontSize": "Taille de la police pour le widget de suggestion. Lorsque la valeur est à `0`, la valeur de `#editor.fontSize` est utilisée.",
"suggestLineHeight": "Hauteur de ligne du widget de suggestion. Quand la valeur est '0', la valeur de '#editor.lineHeight#' est utilisée. La valeur minimale est 8.",
"suggestFontSize": "Taille de police pour le widget suggest. Lorsqu’elle est définie sur {0}, la valeur de {1} est utilisée.",
"suggestLineHeight": "Hauteur de ligne pour le widget suggest. Lorsqu’elle est définie sur {0}, la valeur de {1} est utilisée. La valeur minimale est 8.",
"suggestOnTriggerCharacters": "Contrôle si les suggestions devraient automatiquement s’afficher lorsque vous tapez les caractères de déclencheur.",
"suggestSelection": "Contrôle comment les suggestions sont pré-sélectionnés lors de l’affichage de la liste de suggestion.",
"suggestSelection.first": "Sélectionnez toujours la première suggestion.",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Désactiver les complétions par tabulation.",
"tabCompletion.on": "La complétion par tabulation insérera la meilleure suggestion lorsque vous appuyez sur tab.",
"tabCompletion.onlySnippets": "Compléter les extraits de code par tabulation lorsque leur préfixe correspond. Fonctionne mieux quand les 'quickSuggestions' ne sont pas activées.",
"tabFocusMode": "Contrôle si l’éditeur reçoit des onglets ou les reporte au banc d’essai pour la navigation.",
"unfoldOnClickAfterEndOfLine": "Contrôle si le fait de cliquer sur le contenu vide après une ligne pliée déplie la ligne.",
"unicodeHighlight.allowedCharacters": "Définit les caractères autorisés qui ne sont pas mis en surbrillance.",
"unicodeHighlight.allowedLocales": "Les caractères Unicode communs aux paramètres régionaux autorisés ne sont pas mis en surbrillance.",
"unicodeHighlight.ambiguousCharacters": "Contrôle si les caractères mis en surbrillance peuvent être déconcertés avec des caractères ASCII de base, à l’exception de ceux qui sont courants dans les paramètres régionaux utilisateur actuels.",
"unicodeHighlight.includeComments": "Contrôle si les caractères des commentaires doivent également faire l’objet d’une mise en surbrillance Unicode.",
"unicodeHighlight.includeStrings": "Contrôle si les caractères des commentaires doivent également faire l’objet d’une mise en surbrillance Unicode.",
"unicodeHighlight.includeStrings": "Contrôle si les caractères des chaînes de texte doivent également faire l’objet d’une mise en surbrillance Unicode.",
"unicodeHighlight.invisibleCharacters": "Contrôle si les caractères qui réservent de l’espace ou qui n’ont pas de largeur sont mis en surbrillance.",
"unicodeHighlight.nonBasicASCII": "Contrôle si tous les caractères ASCII non basiques sont mis en surbrillance. Seuls les caractères compris entre U+0020 et U+007E, tabulation, saut de ligne et retour chariot sont considérés comme des ASCII de base.",
"unusualLineTerminators": "Supprimez les marques de fin de ligne inhabituelles susceptibles de causer des problèmes.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Les marques de fin de ligne inhabituelles sont ignorées.",
"unusualLineTerminators.prompt": "Les marques de fin de ligne inhabituelles demandent à être supprimées.",
"useTabStops": "L'insertion et la suppression des espaces blancs suit les taquets de tabulation.",
"wordBreak": "Contrôle les règles de séparateur de mots utilisées pour le texte chinois/japonais/coréen (CJC).",
"wordBreak.keepAll": "Les sauts de mots ne doivent pas être utilisés pour le texte chinois/japonais/coréen (CJC). Le comportement du texte non CJC est identique à celui du texte normal.",
"wordBreak.normal": "Utilisez la règle de saut de ligne par défaut.",
"wordSeparators": "Caractères utilisés comme séparateurs de mots durant la navigation ou les opérations basées sur les mots",
"wordWrap": "Contrôle comment les lignes doivent être limitées.",
"wordWrap.bounded": "Les lignes seront terminées au minimum du viewport et `#editor.wordWrapColumn#`.",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "Les lignes justifiées obtiennent une mise en retrait +1 vers le parent.",
"wrappingIndent.none": "Aucune mise en retrait. Les lignes enveloppées commencent à la colonne 1.",
"wrappingIndent.same": "Les lignes enveloppées obtiennent la même mise en retrait que le parent.",
"wrappingStrategy": "Contrôle l'algorithme qui calcule les points de wrapping.",
"wrappingStrategy": "Contrôle l’algorithme qui calcule les points d’habillage. Notez qu’en mode d’accessibilité, les options avancées sont utilisées pour une expérience optimale.",
"wrappingStrategy.advanced": "Délègue le calcul des points de wrapping au navigateur. Il s'agit d'un algorithme lent qui peut provoquer le gel des grands fichiers, mais qui fonctionne correctement dans tous les cas.",
"wrappingStrategy.simple": "Suppose que tous les caractères ont la même largeur. Il s'agit d'un algorithme rapide qui fonctionne correctement pour les polices à espacement fixe et certains scripts (comme les caractères latins) où les glyphes ont la même largeur."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Couleur d’arrière-plan des repères de paire de crochets inactifs (6). Nécessite l’activation des repères de paire de crochets.",
"editorCodeLensForeground": "Couleur pour les indicateurs CodeLens",
"editorCursorBackground": "La couleur de fond du curseur de l'éditeur. Permet de personnaliser la couleur d'un caractère survolé par un curseur de bloc.",
"editorDimmedLineNumber": "Couleur de la ligne finale de l’éditeur lorsque editor.renderFinalNewline est défini sur grisé.",
"editorGhostTextBackground": "Couleur de l’arrière-plan du texte fantôme dans l’éditeur",
"editorGhostTextBorder": "Couleur de bordure du texte fantôme dans l’éditeur.",
"editorGhostTextForeground": "Couleur de premier plan du texte fantôme dans l’éditeur.",
"editorGutter": "Couleur de fond pour la bordure de l'éditeur. La bordure contient les marges pour les symboles et les numéros de ligne.",
"editorIndentGuides": "Couleur des repères de retrait de l'éditeur.",
"editorLineNumbers": "Couleur des numéros de ligne de l'éditeur.",
"editorOverviewRulerBackground": "Couleur d'arrière-plan de la règle d'aperçu de l'éditeur. Utilisée uniquement quand la minimap est activée et placée sur le côté droit de l'éditeur.",
"editorOverviewRulerBackground": "Couleur d’arrière-plan de la règle de vue d’ensemble de l’éditeur.",
"editorOverviewRulerBorder": "Couleur de la bordure de la règle d'aperçu.",
"editorRuler": "Couleur des règles de l'éditeur",
"editorUnicodeHighlight.background": "Couleur de fond utilisée pour mettre en évidence les caractères unicode",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Appuyez sur Tab dans l'éditeur pour déplacer le focus vers le prochain élément pouvant être désigné comme élément actif. La commande {0} ne peut pas être déclenchée par une combinaison de touches.",
"toggleHighContrast": "Activer/désactiver le thème à contraste élevé"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} caractères",
"showMore": "Afficher plus ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Ancre définie sur {0}:{1}",
"cancelSelectionAnchor": "Annuler l'ancre de sélection",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Copier en tant que",
"miCopy": "&&Copier",
"miCut": "Co&&uper",
"miPaste": "Co&&ller"
"miPaste": "Co&&ller",
"share": "Partager"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Une erreur inconnue s'est produite à l'application de l'action du code"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Une erreur inconnue s'est produite à l'application de l'action du code",
"args.schema.apply": "Contrôle quand les actions retournées sont appliquées.",
"args.schema.apply.first": "Appliquez toujours la première action de code retournée.",
"args.schema.apply.ifSingle": "Appliquez la première action de code retournée si elle est la seule.",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Organiser les importations",
"quickfix.trigger.label": "Correction rapide...",
"refactor.label": "Remanier...",
"refactor.preview.label": "Refactoriser avec l’aperçu...",
"source.label": "Action de la source"
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Activez/désactivez l’affichage des en-têtes de groupe dans le menu d’action du code."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Réécrire...",
"codeAction.widget.id.extract": "Extraire...",
"codeAction.widget.id.inline": "Inline...",
"codeAction.widget.id.more": "Plus d’actions...",
"codeAction.widget.id.move": "Déplacer...",
"codeAction.widget.id.quickfix": "Correction rapide...",
"codeAction.widget.id.source": "Action de la source...",
"codeAction.widget.id.surround": "Entourer de..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Masquer désactivé",
"showMoreActions": "Afficher les éléments désactivés"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Afficher les actions de code",
"codeActionWithKb": "Afficher les actions de code ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "Afficher/masquer le commen&&taire de ligne"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Afficher le menu contextuel de l'éditeur"
"action.showContextMenu.label": "Afficher le menu contextuel de l'éditeur",
"context.minimap.minimap": "Minimap",
"context.minimap.renderCharacters": "Afficher les caractères",
"context.minimap.size": "Taille verticale",
"context.minimap.size.fill": "Remplissage",
"context.minimap.size.fit": "Ajuster",
"context.minimap.size.proportional": "Proportionnel",
"context.minimap.slider": "Curseur",
"context.minimap.slider.always": "Toujours",
"context.minimap.slider.mouseover": "Pointer la souris"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Activez/désactivez l’exécution des modifications à partir des extensions lors du collage."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Exécution des gestionnaires de collage..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Restauration du curseur",
"cursor.undo": "Annulation du curseur"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Exécution des gestionnaires de dépôt..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Indique si l'éditeur exécute une opération annulable, par exemple 'Avoir un aperçu des références'"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Remplace l’indicateur « Cas mathématiques ».\r\nL’indicateur ne sera pas enregistré à l’avenir.\r\n0 : Ne rien faire\r\n1 : Vrai\r\n2 : Faux",
"actions.find.preserveCaseOverride": "Remplace l’indicateur « Preserve Case ».\r\nL’indicateur ne sera pas enregistré à l’avenir.\r\n0 : Ne rien faire\r\n1 : Vrai\r\n2 : Faux",
"actions.find.wholeWordOverride": "Remplace l’indicateur « Match Whole Word ».\r\nL’indicateur ne sera pas enregistré à l’avenir.\r\n0 : Ne rien faire\r\n1 : Vrai\r\n2 : Faux",
"findMatchAction.goToMatch": "Accéder à la correspondance...",
"findMatchAction.inputPlaceHolder": "Tapez un nombre pour accéder à une correspondance spécifique (entre 1 et {0})",
"findMatchAction.inputValidationMessage": "Veuillez entrer un nombre compris entre 1 et {0}",
"findNextMatchAction": "Rechercher suivant",
"findPreviousMatchAction": "Rechercher précédent",
"miFind": "&&Rechercher",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Seuls les {0} premiers résultats sont mis en évidence, mais toutes les opérations de recherche fonctionnent sur l’ensemble du texte."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Couleur du contrôle de pliage dans la marge de l'éditeur.",
"createManualFoldRange.label": "Créer une plage de pliage à partir de la sélection",
"foldAction.label": "Plier",
"foldAllAction.label": "Plier tout",
"foldAllBlockComments.label": "Replier tous les commentaires de bloc",
"foldAllExcept.label": "Plier toutes les régions sauf celles sélectionnées",
"foldAllMarkerRegions.label": "Replier toutes les régions",
"foldBackgroundBackground": "Couleur d'arrière-plan des gammes pliées. La couleur ne doit pas être opaque pour ne pas cacher les décorations sous-jacentes.",
"foldLevelAction.label": "Niveau de pliage {0}",
"foldRecursivelyAction.label": "Plier de manière récursive",
"gotoNextFold.label": "Accéder à la plage de pliage suivante",
"gotoParentFold.label": "Atteindre le pli parent",
"gotoPreviousFold.label": "Accéder à la plage de pliage précédente",
"maximum fold ranges": "Le nombre de régions pliables est limité à un maximum de {0}. Augmentez l’option de configuration ['Folding Maximum Regions'](command:workbench.action.openSettings?[\"editor.foldingMaximumRegions\"]) pour en activer d’autres.",
"removeManualFoldingRanges.label": "Supprimer les plages de pliage manuelles",
"toggleFoldAction.label": "Activer/désactiver le pliage",
"unFoldRecursivelyAction.label": "Déplier de manière récursive",
"unfoldAction.label": "Déplier",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Déplier toutes les régions"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Couleur du contrôle de pliage dans la marge de l'éditeur.",
"foldBackgroundBackground": "Couleur d'arrière-plan des gammes pliées. La couleur ne doit pas être opaque pour ne pas cacher les décorations sous-jacentes.",
"foldingCollapsedIcon": "Icône des plages réduites dans la marge de glyphes de l'éditeur.",
"foldingExpandedIcon": "Icône des plages développées dans la marge de glyphes de l'éditeur."
"foldingExpandedIcon": "Icône des plages développées dans la marge de glyphes de l'éditeur.",
"foldingManualCollapedIcon": "Icône pour les plages réduites manuellement dans la marge de glyphe de l’éditeur.",
"foldingManualExpandedIcon": "Icône pour les plages développées manuellement dans la marge de glyphe de l’éditeur."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Agrandissement de l'éditeur de polices de caractères",
@ -772,11 +881,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.goToDeclToSide.label": "Ouvrir la définition sur le côté",
"actions.goToDeclaration.label": "Accéder à la déclaration",
"actions.goToImplementation.label": "Atteindre les implémentations",
"actions.goToTypeDefinition.label": "Atteindre la définition de type",
"actions.goToTypeDefinition.label": "Atteindre la définition du type",
"actions.peekDecl.label": "Aperçu de la déclaration",
"actions.peekImplementation.label": "Implémentations d'aperçu",
"actions.peekImplementation.label": "Aperçu des implémentations",
"actions.peekTypeDefinition.label": "Aperçu de la définition du type",
"actions.previewDecl.label": "Faire un Peek de la Définition",
"actions.previewDecl.label": "Aperçu de la définition",
"decl.generic.noResults": "Aucune déclaration",
"decl.noResultWord": "Aucune déclaration pour '{0}'",
"decl.title": "Déclarations",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Chargement en cours...",
"stopped rendering": "Rendu suspendu pour une longue ligne pour des raisons de performances. Cela peut être configuré via 'editor.stopRenderingLineAfter'.",
"too many characters": "La tokenisation des lignes longues est ignorée pour des raisons de performances. Cela peut être configurée via 'editor.maxTokenizationLineLength'."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Voir le problème"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Modifier la taille d’affichage de l’onglet",
"configuredTabSize": "Taille des tabulations configurée",
"currentTabSize": "Taille actuelle de l’onglet",
"defaultTabSize": "Taille d’onglet par défaut",
"detectIndentation": "Détecter la mise en retrait à partir du contenu",
"editor.reindentlines": "Remettre en retrait les lignes",
"editor.reindentselectedlines": "Réindenter les lignes sélectionnées",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd + clic"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Accepter",
"acceptWord": "Accepter le mot",
"action.inlineSuggest.accept": "Accepter la suggestion inline",
"action.inlineSuggest.acceptNextWord": "Accepter le mot suivant de la suggestion inline",
"action.inlineSuggest.alwaysShowToolbar": "Toujours afficher la barre d’outils",
"action.inlineSuggest.hide": "Masquer la suggestion inlined",
"action.inlineSuggest.showNext": "Afficher la suggestion en ligne suivante",
"action.inlineSuggest.showPrevious": "Afficher la suggestion en ligne précédente",
"action.inlineSuggest.trigger": "Déclencher la suggestion en ligne",
"action.inlineSuggest.undo": "Annuler l’acceptation du mot",
"alwaysShowInlineSuggestionToolbar": "Indique si la barre d’outils de suggestion en ligne doit toujours être visible",
"canUndoInlineSuggestion": "Indique si l’annulation annulerait une suggestion inline",
"inlineSuggestionHasIndentation": "Indique si la suggestion en ligne commence par un espace blanc",
"inlineSuggestionHasIndentationLessThanTabSize": "Indique si la suggestion incluse commence par un espace blanc inférieur à ce qui serait inséré par l’onglet.",
"inlineSuggestionVisible": "Indique si une suggestion en ligne est visible"
"inlineSuggestionVisible": "Indique si une suggestion en ligne est visible",
"undoAcceptWord": "Annuler l’acceptation du mot"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Suggestion :"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Suivant",
"parameterHintsNextIcon": "Icône d'affichage du prochain conseil de paramètre.",
"parameterHintsPreviousIcon": "Icône d'affichage du précédent conseil de paramètre.",
"previous": "Précédent"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Remplacer par la valeur suivante",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Dupliquer la sélection",
"editor.transformToCamelcase": "Transformer en casse mixte",
"editor.transformToKebabcase": "Transformer en kebab case",
"editor.transformToLowercase": "Transformer en minuscule",
"editor.transformToSnakecase": "Transformer en snake case",
"editor.transformToTitlecase": "Appliquer la casse \"1re lettre des mots en majuscule\"",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Exécuter la commande {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Impossible de modifier dans l’éditeur en lecture seule",
"messageVisible": "Indique si l'éditeur affiche un message inline"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Déplacer la dernière sélection à la correspondance de recherche précédente",
"mutlicursor.addCursorsToBottom": "Ajouter des curseurs en bas",
"mutlicursor.addCursorsToTop": "Ajouter des curseurs en haut",
"mutlicursor.focusNextCursor": "Focus sur le curseur suivant",
"mutlicursor.focusNextCursor.description": "Concentre le curseur suivant",
"mutlicursor.focusPreviousCursor": "Focus sur le curseur précédent",
"mutlicursor.focusPreviousCursor.description": "Concentre le curseur précédent",
"mutlicursor.insertAbove": "Ajouter un curseur au-dessus",
"mutlicursor.insertAtEndOfEachLineSelected": "Ajouter des curseurs à la fin des lignes",
"mutlicursor.insertBelow": "Ajouter un curseur en dessous",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Couleur d'arrière-plan de la bordure de l'éditeur d'affichage d'aperçu.",
"peekViewEditorMatchHighlight": "Couleur de mise en surbrillance d'une correspondance dans l'éditeur de l'affichage d'aperçu.",
"peekViewEditorMatchHighlightBorder": "Bordure de mise en surbrillance d'une correspondance dans l'éditeur de l'affichage d'aperçu.",
"peekViewEditorStickScrollBackground": "Couleur d’arrière-plan du défilement rémanent dans l’éditeur d’affichage d’aperçu.",
"peekViewResultsBackground": "Couleur d'arrière-plan de la liste des résultats de l'affichage d'aperçu.",
"peekViewResultsFileForeground": "Couleur de premier plan des noeuds de fichiers dans la liste des résultats de l'affichage d'aperçu.",
"peekViewResultsMatchForeground": "Couleur de premier plan des noeuds de lignes dans la liste des résultats de l'affichage d'aperçu.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "paramètres de type ({0})",
"variable": "variables ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Impossible de modifier dans l’éditeur en lecture seule",
"editor.simple.readonly": "Impossible de modifier dans l’entrée en lecture seule"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "'{0}' renommé en '{1}'. Récapitulatif : {2}",
"enablePreview": "Activer/désactiver la possibilité d'afficher un aperçu des changements avant le renommage",
"label": "Renommage de '{0}'",
"label": "Renommage de '{0}' en '{1}'",
"no result": "Aucun résultat.",
"quotableLabel": "Changement du nom de {0}",
"quotableLabel": "Changement du nom de {0} en {1}",
"rename.failed": "Le renommage n'a pas pu calculer les modifications",
"rename.failedApply": "Le renommage n'a pas pu appliquer les modifications",
"rename.label": "Renommer le symbole",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Indique s'il existe un taquet de tabulation suivant en mode extrait",
"hasPrevTabstop": "Indique s'il existe un taquet de tabulation précédent en mode extrait",
"inSnippetMode": "Indique si l'éditeur est actualisé en mode extrait"
"inSnippetMode": "Indique si l'éditeur est actualisé en mode extrait",
"next": "Accéder à l’espace réservé suivant..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Avril",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Mercredi",
"WednesdayShort": "Mer"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Défilement épinglé",
"mitoggleStickyScroll": "&&Activer/désactiver le défilement épinglé",
"stickyScroll": "Défilement épinglé",
"toggleStickyScroll": "Activer/désactiver le défilement épinglé"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Indique si les suggestions sont insérées quand vous appuyez sur Entrée",
"suggestWidgetDetailsVisible": "Indique si les détails des suggestions sont visibles",
"suggestWidgetHasSelection": "Indique si une suggestion a le focus",
"suggestWidgetMultipleSuggestions": "Indique s'il existe plusieurs suggestions au choix",
"suggestionCanResolve": "Indique si la suggestion actuelle prend en charge la résolution des détails supplémentaires",
"suggestionHasInsertAndReplaceRange": "Indique si la suggestion actuelle a un comportement d'insertion et de remplacement",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Icône d'affichage d'informations supplémentaires dans le widget de suggestion."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Couleur de premier plan des symboles de tableau. Ces symboles apparaissent dans le plan, la barre de navigation et le widget de suggestion.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "Le fichier « {0} »contient un ou plusieurs caractères de fin de ligne inhabituels, par exemple le séparateur de ligne (LS) ou le séparateur de paragraphe (PS).\r\n\r\nIl est recommandé de les supprimer du fichier. Vous pouvez configurer ce comportement par le biais de `editor.unusualLineTerminators`.",
"unusualLineTerminators.fix": "Supprimer les marques de fin de ligne inhabituelles",
"unusualLineTerminators.fix": "&&Supprimer les marques de fin de ligne inhabituelles",
"unusualLineTerminators.ignore": "Ignorer",
"unusualLineTerminators.message": "Marques de fin de ligne inhabituelles détectées",
"unusualLineTerminators.title": "Marques de fin de ligne inhabituelles"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Couleur de marqueur de la règle d'aperçu pour la mise en surbrillance des symboles. La couleur ne doit pas être opaque pour ne pas masquer les ornements sous-jacents.",
"overviewRulerWordHighlightStrongForeground": "Couleur de marqueur de la règle d'aperçu pour la mise en surbrillance des symboles d'accès en écriture. La couleur ne doit pas être opaque pour ne pas masquer les ornements sous-jacents.",
"overviewRulerWordHighlightTextForeground": "Couleur de marqueur de règle d’aperçu d’une occurrence textuelle pour un symbole. La couleur ne doit pas être opaque afin de ne pas masquer les décorations sous-jacentes.",
"wordHighlight": "Couleur d'arrière-plan d'un symbole pendant l'accès en lecture, comme la lecture d'une variable. La couleur ne doit pas être opaque pour ne pas masquer les ornements sous-jacents.",
"wordHighlight.next.label": "Aller à la prochaine mise en évidence de symbole",
"wordHighlight.previous.label": "Aller à la mise en évidence de symbole précédente",
"wordHighlight.trigger.label": "Déclencher la mise en évidence de symbole",
"wordHighlightBorder": "Couleur de bordure d'un symbole durant l'accès en lecture, par exemple la lecture d'une variable.",
"wordHighlightStrong": "Couleur d'arrière-plan d'un symbole pendant l'accès en écriture, comme l'écriture d'une variable. La couleur ne doit pas être opaque pour ne pas masquer les ornements sous-jacents.",
"wordHighlightStrongBorder": "Couleur de bordure d'un symbole durant l'accès en écriture, par exemple l'écriture dans une variable."
"wordHighlightStrongBorder": "Couleur de bordure d'un symbole durant l'accès en écriture, par exemple l'écriture dans une variable.",
"wordHighlightText": "Couleur d’arrière-plan d’une occurrence textuelle d’un symbole. La couleur ne doit pas être opaque afin de ne pas masquer les décorations sous-jacentes.",
"wordHighlightTextBorder": "Couleur de bordure d’une occurrence textuelle pour un symbole."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Aller à la prochaine mise en évidence de symbole",
"wordHighlight.previous.label": "Aller à la mise en évidence de symbole précédente",
"wordHighlight.trigger.label": "Déclencher la mise en évidence de symbole"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Supprimer le mot"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Développeur",
"help": "Aide",
"preferences": "Préférences",
"test": "Test",
"view": "Afficher"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Masquer",
"resetThisMenu": "Réinitialiser le menu"
},
"vs/platform/actions/common/menuService": {
"hide.label": "Masquer «{0}»"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Widget d’action",
"customQuickFixWidget.labels": "{0}, raison désactivée : {1}",
"label": "{0} pour appliquer",
"label-preview": "{0} à appliquer, {1} à afficher un aperçu"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Accepter l’action sélectionnée",
"codeActionMenuVisible": "Indique si la liste des widgets d’action est visible",
"hideCodeActionWidget.title": "Masquer le widget d’action",
"previewSelected.title": "Aperçu de l’action sélectionnée",
"selectNextCodeAction.title": "Sélectionner l’action suivante",
"selectPrevCodeAction.title": "Sélectionner l’action précédente"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Ligne de diffusion supprimée",
"audioCues.diffLineInserted": "Ligne de diffusion insérée",
"audioCues.diffLineModified": "Ligne diff modifiée",
"audioCues.lineHasBreakpoint.name": "Point d’arrêt sur ligne",
"audioCues.lineHasError.name": "Erreur sur la ligne",
"audioCues.lineHasFoldedArea.name": "Zone pliée sur la ligne",
"audioCues.lineHasInlineSuggestion.name": "Suggestion inline sur la ligne",
"audioCues.lineHasWarning.name": "Avertissement sur la ligne",
"audioCues.noInlayHints": "Aucun indicateur d’inlay sur la ligne",
"audioCues.notebookCellCompleted": "Cellule de bloc-notes terminée",
"audioCues.notebookCellFailed": "Échec de la cellule de bloc-notes",
"audioCues.onDebugBreak.name": "Débogueur arrêté sur le point d’arrêt",
"audioCues.taskCompleted": "Tâche terminée",
"audioCues.taskFailed": "Échec de la tâche",
"audioCues.terminalBell": "Cloche de terminal",
"audioCues.terminalCommandFailed": "Échec de la commande de terminal",
"audioCues.terminalQuickFix.name": "Correctif rapide de terminal"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "Impossible d’inscrire '{0}'. Le {1} de stratégie associé est déjà inscrit auprès de {2}.",
"config.property.duplicate": "Impossible d'inscrire '{0}'. Cette propriété est déjà inscrite.",
"config.property.empty": "Impossible d'inscrire une propriété vide",
"config.property.languageDefault": "Impossible d'inscrire '{0}'. Ceci correspond au modèle de propriété '\\\\[.*\\\\]$' permettant de décrire les paramètres d'éditeur spécifiques à un langage. Utilisez la contribution 'configurationDefaults'.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Indique si le système d'exploitation est Linux",
"isMac": "Indique si le système d'exploitation est macOS",
"isMacNative": "Indique si le système d'exploitation est macOS sur une plateforme qui n'est pas un navigateur",
"isMobile": "Indique si la plateforme est un navigateur web mobile",
"isWeb": "Indique si la plateforme est un navigateur web",
"isWindows": "Indique si le système d'exploitation est Windows"
"isWindows": "Indique si le système d'exploitation est Windows",
"productQualityType": "Type de qualité de VS Code"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Annuler",
"moreFile": "...1 fichier supplémentaire non affiché",
"moreFiles": "...{0} fichiers supplémentaires non affichés"
"moreFiles": "...{0} fichiers supplémentaires non affichés",
"okButton": "&&OK",
"yesButton": "&&Oui"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "Le fichier est trop volumineux pour être ouvert en tant qu'éditeur sans titre. Chargez-le d'abord dans l'Explorateur de fichiers, puis réessayez."
},
"vs/platform/files/common/files": {
"sizeB": "{0} o",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Multiplicateur de vitesse de défilement quand vous appuyez sur 'Alt'.",
"Mouse Wheel Scroll Sensitivity": "Un multiplicateur à utiliser sur les `deltaX` et `deltaY` des événements de défilement de roulette de souris.",
"automatic keyboard navigation setting": "Contrôle si la navigation au clavier dans les listes et les arborescences est automatiquement déclenchée simplement par la frappe. Si défini sur 'false', la navigation au clavier est seulement déclenchée avec l'exécution de la commande 'list.toggleKeyboardNavigation', à laquelle vous pouvez attribuer un raccourci clavier.",
"defaultFindMatchTypeSettingKey": "Contrôle le type de correspondance utilisé lors de la recherche de listes et d’arborescences dans le banc d’essai.",
"defaultFindMatchTypeSettingKey.contiguous": "Utilisez des correspondances contiguës lors de la recherche.",
"defaultFindMatchTypeSettingKey.fuzzy": "Utilisez la correspondance approximative lors de la recherche.",
"defaultFindModeSettingKey": "Contrôle le mode de recherche par défaut pour les listes et les arborescences dans Workbench.",
"defaultFindModeSettingKey.filter": "Filtrez des éléments lors de la recherche.",
"defaultFindModeSettingKey.highlight": "Mettez en surbrillance les éléments lors de la recherche. La navigation vers le haut et le bas traverse uniquement les éléments en surbrillance.",
"expand mode": "Contrôle la façon dont les dossiers de l'arborescence sont développés quand vous cliquez sur les noms de dossiers. Notez que certaines arborescences et listes peuvent choisir d'ignorer ce paramètre, s'il est non applicable.",
"horizontalScrolling setting": "Contrôle si les listes et les arborescences prennent en charge le défilement horizontal dans le banc d'essai. Avertissement : L'activation de ce paramètre a un impact sur les performances.",
"keyboardNavigationSettingKey": "Contrôle le style de navigation au clavier pour les listes et les arborescences dans le banc d'essai. Les options sont Simple, Mise en surbrillance et Filtrer.",
"keyboardNavigationSettingKey.filter": "La navigation au clavier Filtrer filtre et masque tous les éléments qui ne correspondent pas à l'entrée de clavier.",
"keyboardNavigationSettingKey.highlight": "La navigation de mise en surbrillance au clavier met en surbrillance les éléments qui correspondent à l'entrée de clavier. La navigation ultérieure vers le haut ou vers le bas parcourt uniquement les éléments mis en surbrillance.",
"keyboardNavigationSettingKey.simple": "La navigation au clavier Simple place le focus sur les éléments qui correspondent à l'entrée de clavier. La mise en correspondance est effectuée sur les préfixes uniquement.",
"keyboardNavigationSettingKeyDeprecated": "Utilisez 'workbench.list.defaultFindMode' et 'workbench.list.typeNavigationMode' à la place.",
"list smoothScrolling setting": "Détermine si les listes et les arborescences ont un défilement fluide.",
"list.scrollByPage": "Contrôle si les clics dans la barre de défilement page par page.",
"multiSelectModifier": "Le modificateur à utiliser pour ajouter un élément dans les arbres et listes pour une sélection multiple avec la souris (par exemple dans l’Explorateur, les éditeurs ouverts et la vue scm). Les mouvements de la souris 'Ouvrir à côté' (si pris en charge) s'adapteront tels qu’ils n'entrent pas en conflit avec le modificateur multiselect.",
"multiSelectModifier.alt": "Mappe vers 'Alt' dans Windows et Linux, et vers 'Option' dans macOS.",
"multiSelectModifier.ctrlCmd": "Mappe vers 'Contrôle' dans Windows et Linux, et vers 'Commande' dans macOS.",
"openModeModifier": "Contrôle l'ouverture des éléments dans les arborescences et les listes à l'aide de la souris (si cela est pris en charge). Notez que certaines arborescences et listes peuvent choisir d'ignorer ce paramètre, s'il est non applicable.",
"render tree indent guides": "Contrôle si l'arborescence doit afficher les repères de mise en retrait.",
"tree indent setting": "Contrôle la mise en retrait de l'arborescence, en pixels.",
"typeNavigationMode": "Contrôle le fonctionnement de la navigation par type dans les listes et les arborescences du banc d’essai. Quand la valeur est 'trigger', la navigation de type commence une fois que la commande 'list.triggerTypeNavigation' est exécutée.",
"workbenchConfigurationTitle": "Banc d'essai"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Avertissement"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "La commande '{0}' a entraîné une erreur ({1})",
"canNotRun": "La commande « {0} » a entraîné une erreur",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "utilisés le plus souvent",
"morecCommands": "autres commandes",
"recentlyUsed": "récemment utilisées"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "commandes de l'éditeur",
"globalCommands": "commandes globales",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Personnalisé",
"inputModeEntry": "Appuyez sur 'Entrée' pour confirmer votre saisie, ou sur 'Échap' pour l'annuler",
"inputModeEntryDescription": "{0} (Appuyez sur 'Entrée' pour confirmer ou sur 'Échap' pour annuler)",
"ok": "OK",
"quickInput.back": "Précédent",
"quickInput.backWithKeybinding": "Précédent ({0})",
"quickInput.checkAll": "Activer/désactiver toutes les cases à cocher",
"quickInput.countSelected": "{0} Sélectionnés",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} résultats",
"quickInputBox.ariaLabel": "Taper pour affiner les résultats."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Entrée rapide"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Cliquer pour exécuter la commande '{0}'"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Bordure supplémentaire autour des éléments actifs pour les séparer des autres et obtenir un meilleur contraste.",
"activeLinkForeground": "Couleur des liens actifs.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Couleur de fond des éléments de navigation.",
"breadcrumbsFocusForeground": "Couleur des éléments de navigation avec le focus.",
"breadcrumbsSelectedBackground": "Couleur de fond du sélecteur d’élément de navigation.",
"breadcrumbsSelectedForegound": "Couleur des éléments de navigation sélectionnés.",
"breadcrumbsSelectedForeground": "Couleur des éléments de navigation sélectionnés.",
"buttonBackground": "Couleur d'arrière-plan du bouton.",
"buttonBorder": "Couleur de bordure du bouton.",
"buttonForeground": "Couleur de premier plan du bouton.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Couleur d'arrière-plan du bouton secondaire.",
"buttonSecondaryForeground": "Couleur de premier plan du bouton secondaire.",
"buttonSecondaryHoverBackground": "Couleur d'arrière-plan du bouton secondaire au moment du pointage.",
"buttonSeparator": "Couleur du séparateur de boutons.",
"chartsBlue": "Couleur bleue utilisée dans les visualisations de graphiques.",
"chartsForeground": "Couleur de premier plan utilisée dans les graphiques.",
"chartsGreen": "Couleur verte utilisée dans les visualisations de graphiques.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Couleur de fond du widget Case à cocher.",
"checkbox.border": "Couleur de bordure du widget Case à cocher.",
"checkbox.foreground": "Couleur de premier plan du widget Case à cocher.",
"checkbox.select.background": "Couleur d’arrière-plan du widget de case à cocher lorsque l’élément dans lequel il se trouve est sélectionné.",
"checkbox.select.border": "Couleur de bordure du widget de case à cocher lorsque l’élément dans lequel il se trouve est sélectionné.",
"contrastBorder": "Bordure supplémentaire autour des éléments pour les séparer des autres et obtenir un meilleur contraste.",
"descriptionForeground": "Couleur de premier plan du texte descriptif fournissant des informations supplémentaires, par exemple pour un label.",
"diffDiagonalFill": "Couleur du remplissage diagonal de l'éditeur de différences. Le remplissage diagonal est utilisé dans les vues de différences côte à côte.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Couleur d’arrière-plan de la marge où les lignes ont été supprimées",
"diffEditorRemovedLines": "Couleur d'arrière-plan des lignes supprimées. La couleur ne doit pas être opaque pour ne pas masquer les ornements sous-jacents.",
"diffEditorRemovedOutline": "Couleur de contour du texte supprimé.",
"disabledForeground": "Premier plan globale pour les éléments désactivés. Cette couleur est utilisée si elle n'est pas remplacée par un composant.",
"dropdownBackground": "Arrière-plan de la liste déroulante.",
"dropdownBorder": "Bordure de la liste déroulante.",
"dropdownForeground": "Premier plan de la liste déroulante.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Couleur du texte sélectionné pour le contraste élevé.",
"editorSelectionHighlight": "Couleur des régions dont le contenu est le même que celui de la sélection. La couleur ne doit pas être opaque pour ne pas masquer les ornements sous-jacents.",
"editorSelectionHighlightBorder": "Couleur de bordure des régions dont le contenu est identique à la sélection.",
"editorStickyScrollBackground": "Couleur d’arrière-plan du défilement pense-bête pour l’éditeur",
"editorStickyScrollHoverBackground": "Faire défiler l’écran sur la couleur d’arrière-plan du pointage pour l’éditeur",
"editorWarning.background": "Couleur d'arrière-plan du texte d'avertissement dans l'éditeur. La couleur ne doit pas être opaque pour ne pas masquer les décorations sous-jacentes.",
"editorWarning.foreground": "Couleur de premier plan de la ligne ondulée marquant les avertissements dans l'éditeur.",
"editorWidgetBackground": "Couleur d'arrière-plan des gadgets de l'éditeur tels que rechercher/remplacer.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Couleur d'arrière-plan du widget de filtre de type dans les listes et les arborescences.",
"listFilterWidgetNoMatchesOutline": "Couleur de contour du widget de filtre de type dans les listes et les arborescences, en l'absence de correspondance.",
"listFilterWidgetOutline": "Couleur de contour du widget de filtre de type dans les listes et les arborescences.",
"listFilterWidgetShadow": "Appliquez une ombre à la couleur du widget filtre de type dans les listes et les arborescences.",
"listFocusAndSelectionOutline": "Couleur de contour de liste/arborescence pour l’élément ciblé lorsque la liste/l’arborescence est active et sélectionnée. Une liste/arborescence active dispose d’un focus clavier, ce qui n’est pas le cas d’une arborescence inactive.",
"listFocusBackground": "Couleur d'arrière-plan de la liste/l'arborescence pour l'élément ayant le focus quand la liste/l'arborescence est active. Une liste/arborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
"listFocusForeground": "Couleur de premier plan de la liste/l'arborescence pour l'élément ayant le focus quand la liste/l'arborescence est active. Une liste/arborescence active peut être sélectionnée au clavier, elle ne l'est pas quand elle est inactive.",
"listFocusHighlightForeground": "Couleur de premier plan de la liste ou l’arborescence pour la surbrillance des correspondances sur les éléments ayant le focus pendant la recherche dans une liste/arborescence.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Arrière-plan de la barre d’outils quand la souris est maintenue sur des actions",
"toolbarHoverBackground": "Arrière-plan de la barre d’outils lors du survol des actions à l’aide de la souris",
"toolbarHoverOutline": "Contour de la barre d’outils lors du survol des actions à l’aide de la souris",
"treeInactiveIndentGuidesStroke": "Couleur de trait d’arborescence pour les repères de mise en retrait qui ne sont pas actifs.",
"treeIndentGuidesStroke": "Couleur de trait de l'arborescence pour les repères de mise en retrait.",
"warningBorder": "Couleur de bordure des zones d'avertissement dans l'éditeur.",
"widgetBorder": "Couleur de bordure des widgets, comme rechercher/remplacer au sein de l'éditeur.",
"widgetShadow": "Couleur de l'ombre des widgets, comme rechercher/remplacer, au sein de l'éditeur."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Icône de l'action de fermeture dans les widgets."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Annuler",
"cannotResourceRedoDueToInProgressUndoRedo": "Impossible de rétablir '{0}', car une opération d'annulation ou de rétablissement est déjà en cours d'exécution.",
"cannotResourceUndoDueToInProgressUndoRedo": "Impossible d'annuler '{0}', car une opération d'annulation ou de rétablissement est déjà en cours d'exécution.",
"cannotWorkspaceRedo": "Impossible de répéter '{0}' dans tous les fichiers. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "Impossible d'annuler '{0}' dans tous les fichiers, car une opération d'annulation ou de rétablissement est déjà en cours d'exécution sur {1}",
"confirmDifferentSource": "Voulez-vous annuler '{0}' ?",
"confirmDifferentSource.no": "Non",
"confirmDifferentSource.yes": "Oui",
"confirmDifferentSource.yes": "&&Oui",
"confirmWorkspace": "Souhaitez-vous annuler '{0}' dans tous les fichiers ?",
"externalRemoval": "Les fichiers suivants ont été fermés et modifiés sur le disque : {0}.",
"noParallelUniverses": "Les fichiers suivants ont été modifiés de manière incompatible : {0}.",
"nok": "Annuler ce fichier",
"ok": "Annuler dans {0} fichiers"
"nok": "Annuler ce &&fichier",
"ok": "&&Annuler dans {0} fichiers"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Espace de travail de code"

402
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/it.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Altre azioni..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Chiudi finestra di dialogo",
"dialogErrorMessage": "Errore",
"dialogInfoMessage": "Informazioni",
"dialogPendingMessage": "In corso",
"dialogWarningMessage": "Avviso",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Altre azioni..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "input"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Maiuscole/minuscole",
"regexDescription": "Usa espressione regolare",
"wordsDescription": "Parola intera"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "input",
"label.preserveCaseToggle": "Mantieni maiuscole/minuscole"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Non associato"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Casella di selezione"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Altre azioni..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Cancella",
"disable filter on type": "Disabilita filtro sul tipo",
"empty": "Non sono stati trovati elementi",
"enable filter on type": "Abilita filtro sul tipo",
"found": "Abbinamento di {0} su {1} elementi"
"close": "Chiudi",
"filter": "Filtro",
"fuzzySearch": "Corrispondenza fuzzy",
"not found": "Non sono stati trovati elementi.",
"type to filter": "Digitare per filtrare",
"type to search": "Digitare per la ricerca"
},
"vs/base/common/actions": {
"submenu.empty": "(vuoto)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Personalizzato",
"inputModeEntry": "Premere 'INVIO' per confermare l'input oppure 'ESC' per annullare",
"inputModeEntryDescription": "{0} (premere 'INVIO' per confermare oppure 'ESC' per annullare)",
"ok": "OK",
"quickInput.back": "Indietro",
"quickInput.backWithKeybinding": "Indietro ({0})",
"quickInput.countSelected": "{0} selezionati",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} risultati",
"quickInputBox.ariaLabel": "Digitare per ridurre il numero di risultati."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Input rapido"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "L'editor non è accessibile in questo momento. Premere {0} per le opzioni.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Annulla azione"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "Il numero di cursori è stato limitato a {0}."
"cursors.maximum": "Il numero di cursori è stato limitato a {0}. Provare a usare [Trova e sostituisci](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) per modifiche di dimensioni maggiori o aumentare l'impostazione del limite di più cursori dell'editor.",
"goToSetting": "Aumentare limite multi-cursore"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " usa MAIUSC +F7 per esplorare le modifiche",
"diff.tooLarge": "Non è possibile confrontare i file perché uno è troppo grande.",
"diffInsertIcon": "Effetto di riga per gli inserimenti nell'editor diff.",
"diffRemoveIcon": "Effetto di riga per le rimozioni nell'editor diff."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Controlla se l'editor visualizza CodeLens.",
"detectIndentation": "Controlla se `#editor.tabSize#` e `#editor.insertSpaces#` verranno rilevati automaticamente quando un file viene aperto in base al contenuto del file.",
"detectIndentation": "Controlla se {0} e {1} verranno rilevati automaticamente quando un file viene aperto in base al contenuto del file.",
"diffAlgorithm.experimental": "Usa un algoritmo diffing sperimentale.",
"diffAlgorithm.smart": "Usa l'algoritmo diffing predefinito.",
"editor.experimental.asyncTokenization": "Controlla se la tokenizzazione deve essere eseguita in modo asincrono in un web worker.",
"editorConfigurationTitle": "Editor",
"ignoreTrimWhitespace": "Se abilitato, l'editor differenze ignora le modifiche relative a spazi vuoti iniziali e finali.",
"insertSpaces": "Inserisce spazi quando viene premuto TAB. Quando `#editor.detectIndentation#` è attivo, questa impostazione viene sostituita in base al contenuto del file.",
"indentSize": "Numero di spazi utilizzati per il rientro o `\"tabSize\"` per usare il valore di `#editor.tabSize#`. Questa impostazione viene sostituita in base al contenuto del file quando `#editor.detectIndentation#` è attivo.",
"insertSpaces": "Inserire spazi quando si preme 'TAB'. Questa impostazione viene sottoposta a override in base al contenuto del file quando {0} è attivo.",
"largeFileOptimizations": "Gestione speciale dei file di grandi dimensioni per disabilitare alcune funzionalità che fanno un uso intensivo della memoria.",
"maxComputationTime": "Timeout in millisecondi dopo il quale il calcolo delle differenze viene annullato. Usare 0 per indicare nessun timeout.",
"maxFileSize": "Dimensioni massime del file in MB per cui calcolare le differenze. Usare 0 per nessun limite.",
"maxTokenizationLineLength": "Per motivi di prestazioni le righe di lunghezza superiore non verranno tokenizzate",
"renderIndicators": "Controlla se l'editor diff mostra gli indicatori +/- per le modifiche aggiunte/rimosse.",
"renderMarginRevertIcon": "Se questa opzione è abilitata, l'editor diff mostra le frecce nel margine del glifo per ripristinare le modifiche.",
"schema.brackets": "Definisce i simboli di parentesi quadra che aumentano o riducono il rientro.",
"schema.closeBracket": "Sequenza di stringa o carattere parentesi quadra di chiusura.",
"schema.colorizedBracketPairs": "Definisce le coppie di bracket colorate in base al livello di annidamento se è abilitata la colorazione delle coppie di bracket.",
@ -139,15 +160,15 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.false": "L'evidenziazione semantica è disabilitata per tutti i temi colore.",
"semanticHighlighting.true": "L'evidenziazione semantica è abilitata per tutti i temi colore.",
"sideBySide": "Controlla se l'editor diff mostra le differenze affiancate o incorporate.",
"stablePeek": "Mantiene aperti gli editor rapidi anche quando si fa doppio clic sul contenuto o si preme 'ESC'.",
"tabSize": "Numero di spazi a cui equivale una tabulazione. Quando `#editor.detectIndentation#` è attivo, questa impostazione viene sostituita in base al contenuto del file.",
"stablePeek": "Consente di mantenere aperti gli editor rapidi anche quando si fa doppio clic sul contenuto o si preme 'ESC'.",
"tabSize": "Numero di spazi a cui è uguale una scheda. Questa impostazione viene sottoposta a override in base al contenuto del file quando {0} è attivo.",
"trimAutoWhitespace": "Rimuovi gli spazi finali inseriti automaticamente.",
"wordBasedSuggestions": "Controlla se calcolare i completamenti in base alle parole presenti nel documento.",
"wordBasedSuggestionsMode": "Controlla i documenti da cui vengono calcolati i completamenti basati su parole.",
"wordBasedSuggestionsMode.allDocuments": "Suggerisci parole da tutti i documenti aperti.",
"wordBasedSuggestionsMode.currentDocument": "Suggerisci parole solo dal documento attivo.",
"wordBasedSuggestionsMode.matchingDocuments": "Suggerisci parole da tutti i documenti aperti della stessa lingua.",
"wordWrap.inherit": "Il ritorno a capo automatico delle righe viene applicato in base all'impostazione `#editor.wordWrap#`.",
"wordWrap.inherit": "Le righe andranno a capo in base all'impostazione {0}.",
"wordWrap.off": "Il ritorno a capo automatico delle righe non viene mai applicato.",
"wordWrap.on": "Il ritorno a capo automatico delle righe viene applicato in corrispondenza della larghezza del viewport."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Controlla se i suggerimenti devono essere accettati con 'INVIO' in aggiunta a 'TAB'. In questo modo è possibile evitare ambiguità tra l'inserimento di nuove righe e l'accettazione di suggerimenti.",
"acceptSuggestionOnEnterSmart": "Accetta un suggerimento con 'Invio' solo quando si apporta una modifica al testo.",
"accessibilityPageSize": "Controlla il numero di righe nell'Editor che possono essere lette alla volta da un utilità per la lettura dello schermo. Quando viene rilevata un'utilità per la lettura dello schermo, questo valore viene impostato su 500 per impostazione predefinita. Avviso: questa opzione può influire sulle prestazioni se il numero di righe è superiore a quello predefinito.",
"accessibilitySupport": "Controlla se l'editor deve essere eseguito in una modalità ottimizzata per le utilità per la lettura dello schermo. Se viene attivata, il ritorno a capo automatico verrà disabilitato.",
"accessibilitySupport.auto": "L'editor userà le API della piattaforma per rilevare quando viene collegata un'utilità per la lettura dello schermo.",
"accessibilitySupport.off": "L'editor non verrà mai ottimizzato per l'utilizzo con un'utilità per la lettura dello schermo.",
"accessibilitySupport.on": "L'editor verrà definitivamente ottimizzato per l'utilizzo con un'utilità per la lettura dello schermo. Il ritorno a capo automatico verrà disabilitato.",
"accessibilitySupport": "Controllare se l'interfaccia utente deve essere eseguito in una modalità ottimizzata per le utilità per la lettura dello schermo.",
"accessibilitySupport.auto": "Usare le API della piattaforma per rilevare quando viene collegata un'utilità per la lettura dello schermo",
"accessibilitySupport.off": "Si presuppone che un'utilità per la lettura dello schermo non sia collegata",
"accessibilitySupport.on": "Ottimizzare l'utilizzo con un'utilità per la lettura dello schermo",
"alternativeDeclarationCommand": "ID comando alternativo eseguito quando il risultato di 'Vai a dichiarazione' è la posizione corrente.",
"alternativeDefinitionCommand": "ID comando alternativo eseguito quando il risultato di 'Vai alla definizione' è la posizione corrente.",
"alternativeImplementationCommand": "ID comando alternativo eseguito quando il risultato di 'Vai a implementazione' è la posizione corrente.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Controlla se l'editor deve chiudere automaticamente le citazioni dopo che sono state aperte.",
"autoIndent": "Controlla se l'editor deve regolare automaticamente il rientro quando gli utenti digitano, incollano, spostano le righe o applicano il rientro.",
"autoSurround": "Controlla se l'editor deve racchiudere automaticamente le selezioni quando si digitano virgolette o parentesi quadre.",
"bracketPairColorization.enabled": "Controlla se la colorazione delle coppie di parentesi è abilitata. Usare '#workbench.colorCustomizations#' per eseguire l'override dei colori di evidenziazione delle parentesi.",
"bracketPairColorization.enabled": "Controlla se la colorazione delle coppie di parentesi è abilitata. Usare {0} per eseguire l'override dei colori di evidenziazione delle parentesi.",
"bracketPairColorization.independentColorPoolPerBracketType": "Controlla se ogni tipo di parentesi ha un pool di colori indipendente.",
"codeActions": "Abilita la lampadina delle azioni codice nell'editor.",
"codeLens": "Controlla se l'editor visualizza CodeLens.",
"codeLensFontFamily": "Controlla la famiglia di caratteri per CodeLens.",
"codeLensFontSize": "Controlla le dimensioni del carattere in pixel per CodeLens. Quando è impostata su '0', viene usato il 90% del valore di '#editor.fontSize#'.",
"codeLensFontSize": "Controlla le dimensioni del carattere in pixel per CodeLens. Quando è impostata su 0, viene usato il 90% del valore di '#editor.fontSize#'.",
"colorDecorators": "Controlla se l'editor deve eseguire il rendering della selezione colori e degli elementi Decorator di tipo colore inline.",
"colorDecoratorsLimit": "Controlla il numero massimo di elementi Decorator a colori di cui è possibile eseguire il rendering in un editor contemporaneamente.",
"columnSelection": "Abilita l'uso di mouse e tasti per la selezione delle colonne.",
"comments.ignoreEmptyLines": "Controlla se ignorare le righe vuote con le opzioni per attivare/disattivare, aggiungere o rimuovere relative ai commenti di riga.",
"comments.insertSpace": "Consente di controllare se viene inserito uno spazio quando si aggiungono commenti.",
"copyWithSyntaxHighlighting": "Controlla se l'evidenziazione della sintassi deve essere copiata negli Appunti.",
"cursorBlinking": "Controllo dello stile di animazione del cursore.",
"cursorSmoothCaretAnimation": "Controlla se l'animazione del cursore con anti-aliasing deve essere abilitata.",
"cursorSmoothCaretAnimation.explicit": "L'animazione con cursore uniforme è abilitata solo quando l'utente sposta il cursore con un movimento esplicito.",
"cursorSmoothCaretAnimation.off": "L'animazione con cursore arrotondato è disabilitata.",
"cursorSmoothCaretAnimation.on": "L'animazione con cursore uniforme è sempre abilitata.",
"cursorStyle": "Controlla lo stile del cursore.",
"cursorSurroundingLines": "Controlla il numero minimo di righe iniziali e finali visibili che circondano il cursore. Noto come 'scrollOff' o 'scrollOffset' in altri editor.",
"cursorSurroundingLines": "Controllare il numero minimo di linee iniziali visibili (minimo 0) e finali (minimo 1) visibili che circondano il cursore. Noto come 'scrollOff' o 'scrollOffset' in altri editor.",
"cursorSurroundingLinesStyle": "Controlla quando deve essere applicato `cursorSurroundingLines`.",
"cursorSurroundingLinesStyle.all": "`cursorSurroundingLines` viene sempre applicato.",
"cursorSurroundingLinesStyle.default": "`cursorSurroundingLines` viene applicato solo quando è attivato tramite la tastiera o l'API.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Controlla se il movimento del mouse Vai alla definizione consente sempre di aprire il widget di anteprima.",
"deprecated": "Questa impostazione è deprecata. In alternativa, usare impostazioni diverse, come 'editor.suggest.showKeywords' o 'editor.suggest.showSnippets'.",
"dragAndDrop": "Controlla se l'editor deve consentire lo spostamento di selezioni tramite trascinamento della selezione.",
"dropIntoEditor.enabled": "Controlla se è possibile trascinare un file in un editor di testo tenendo premuto MAIUSC (invece di aprire il file in un editor).",
"editor.autoClosingBrackets.beforeWhitespace": "Chiudi automaticamente le parentesi solo quando il cursore si trova alla sinistra di uno spazio vuoto.",
"editor.autoClosingBrackets.languageDefined": "Usa le configurazioni del linguaggio per determinare la chiusura automatica delle parentesi.",
"editor.autoClosingDelete.auto": "Rimuove le virgolette o le parentesi quadre di chiusura adiacenti solo se sono state inserite automaticamente.",
@ -220,8 +246,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.find.seedSearchStringFromSelection.selection": "Fornisci la stringa di ricerca solo dalla selezione dell'editor.",
"editor.gotoLocation.multiple.deprecated": "Questa impostazione è deprecata. In alternativa, usare impostazioni diverse, come 'editor.editor.gotoLocation.multipleDefinitions' o 'editor.editor.gotoLocation.multipleImplementations'.",
"editor.gotoLocation.multiple.goto": "Passa al risultato principale e abilita l'esplorazione senza anteprima per gli altri",
"editor.gotoLocation.multiple.gotoAndPeek": "Passa al risultato principale e mostra una visualizzazione rapida",
"editor.gotoLocation.multiple.peek": "Mostra la visualizzazione rapida dei risultati (impostazione predefinita)",
"editor.gotoLocation.multiple.gotoAndPeek": "Passa al risultato principale e mostra una visualizzazione in anteprima",
"editor.gotoLocation.multiple.peek": "Mostra la visualizzazione in anteprima dei risultati (impostazione predefinita)",
"editor.guides.bracketPairs": "Controlla se le guide delle coppie di parentesi sono abilitate o meno.",
"editor.guides.bracketPairs.active": "Abilita le guide delle coppie di parentesi solo per la coppia di parentesi attive.",
"editor.guides.bracketPairs.false": "Disabilita le guide per coppie di parentesi quadre.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Abilita le guide orizzontali come aggiunta alle guide per coppie di parentesi verticali.",
"editor.guides.highlightActiveBracketPair": "Controlla se l'editor debba evidenziare la coppia di parentesi attive.",
"editor.guides.highlightActiveIndentation": "Controlla se l'editor deve evidenziare la guida con rientro attiva.",
"editor.guides.highlightActiveIndentation.always": "Evidenzia la guida di rientro attiva anche se le guide delle parentesi quadre sono evidenziate.",
"editor.guides.highlightActiveIndentation.false": "Non evidenziare la guida di rientro attiva.",
"editor.guides.highlightActiveIndentation.true": "Evidenzia la guida di rientro attiva.",
"editor.guides.indentation": "Controlla se l'editor deve eseguire il rendering delle guide con rientro.",
"editor.inlayHints.off": "Gli hint di inlay sono disabilitati",
"editor.inlayHints.offUnlessPressed": "Gli hint di inlay sono nascosti per impostazione predefinita e vengono visualizzati solo quando si tiene premuto {0}",
"editor.inlayHints.on": "Gli hint di inlay sono abilitati",
"editor.inlayHints.onUnlessPressed": "Gli hint di inlay vengono visualizzati per impostazione predefinita e vengono nascosti quando si tiene premuto {0}",
"editor.stickyScroll": "Mostra gli ambiti correnti annidati durante lo scorrimento nella parte superiore dell'editor.",
"editor.stickyScroll.": "Definisce il numero massimo di righe permanenti da mostrare.",
"editor.suggest.matchOnWordStartOnly": "Quando è abilitato, il filtro IntelliSense richiede che il primo carattere corrisponda all'inizio di una parola, ad esempio 'c' per 'Console' o 'WebContext' ma _non_ per 'description'. Quando è disabilitato, IntelliSense mostra più risultati, ma li ordina comunque in base alla qualità della corrispondenza.",
"editor.suggest.showClasss": "Se è abilitata, IntelliSense mostra i suggerimenti relativi a `class`.",
"editor.suggest.showColors": "Se è abilitata, IntelliSense mostra i suggerimenti relativi a `color`.",
"editor.suggest.showConstants": "Se è abilitata, IntelliSense mostra i suggerimenti relativi a `constant`.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Se è abilitata, IntelliSense mostra i suggerimenti relativi a `variable`.",
"editorViewAccessibleLabel": "Contenuto editor",
"emptySelectionClipboard": "Controlla se, quando si copia senza aver effettuato una selezione, viene copiata la riga corrente.",
"experimentalWhitespaceRendering": "Controlla se viene eseguito il rendering degli spazi vuoti con un nuovo metodo sperimentale.",
"experimentalWhitespaceRendering.font": "Usare un nuovo metodo di rendering con tipi di caratteri.",
"experimentalWhitespaceRendering.off": "Usare il metodo di rendering stabile.",
"experimentalWhitespaceRendering.svg": "Usare un nuovo metodo di rendering con svgs.",
"fastScrollSensitivity": "Moltiplicatore della velocità di scorrimento quando si preme `Alt`.",
"find.addExtraSpaceOnTop": "Controlla se il widget Trova deve aggiungere altre righe nella parte superiore dell'editor. Quando è true, è possibile scorrere oltre la prima riga quando il widget Trova è visibile.",
"find.autoFindInSelection": "Controlla la condizione per attivare automaticamente la funzione Trova nella selezione.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Abilita/Disabilita i caratteri legatura (funzionalità dei tipi di carattere 'calt' e 'liga'). Impostare su una stringa per un controllo più specifico sulla proprietà CSS 'font-feature-settings'.",
"fontLigaturesGeneral": "Consente di configurare i caratteri legatura o le funzionalità dei tipi di carattere. Può essere un valore booleano per abilitare/disabilitare le legature o una stringa per il valore della proprietà CSS 'font-feature-settings'.",
"fontSize": "Controlla le dimensioni del carattere in pixel.",
"fontVariationSettings": "Proprietà CSS esplicita 'font-variation-settings'. È invece possibile passare un valore booleano se è sufficiente convertire font-weight in font-variation-settings.",
"fontVariations": "Abilita/disabilita la conversione dada font-weight a font-variation-settings. Modificare questa impostazione in una stringa per il controllo con granularità fine della proprietà CSS Font-variation.",
"fontVariationsGeneral": "Configura le varianti di carattere. Può essere un valore booleano per abilitare/disabilitare la conversione da font-weight a font-variation-settings o una stringa per il valore della proprietà 'font-variation-settings' CSS.",
"fontWeight": "Controlla lo spessore del carattere. Accetta le parole chiave \"normal\" e \"bold\" o i numeri compresi tra 1 e 1000.",
"fontWeightErrorMessage": "Sono consentiti solo le parole chiave \"normal\" e \"bold\" o i numeri compresi tra 1 e 1000.",
"formatOnPaste": "Controlla se l'editor deve formattare automaticamente il contenuto incollato. Deve essere disponibile un formattatore che deve essere in grado di formattare un intervallo in un documento.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Controlla se mostrare l'area sensibile al passaggio del mouse.",
"hover.sticky": "Controlla se l'area sensibile al passaggio del mouse deve rimanere visibile quando vi si passa sopra con il puntatore del mouse.",
"inlayHints.enable": "Abilita i suggerimenti incorporati nell'Editor.",
"inlayHints.fontFamily": "Controlla la famiglia di caratteri dei suggerimenti incorporati nell'Editor. Se impostato su vuoto, viene usato '#editor.fontFamily#'.",
"inlayHints.fontSize": "Controlla le dimensioni del carattere dei suggerimenti incorporati nell'editor. Viene usato il valore predefinito 90% di `#editor.fontSize#` quando il valore configurato è minore di `5` o maggiore delle dimensioni del carattere dell'editor.",
"inlayHints.fontFamily": "Controlla la famiglia di caratteri dei suggerimenti inlay nell'editor. Se impostato su vuoto, viene usato {0}.",
"inlayHints.fontSize": "Controlla le dimensioni del carattere dei suggerimenti di inlay nell'editor. Per impostazione predefinita, {0} viene usato quando il valore configurato è minore di {1} o maggiore delle dimensioni del carattere dell'editor.",
"inlayHints.padding": "Abilita il riempimento attorno ai suggerimenti incorporati nell'editor.",
"inline": "I suggerimenti rapidi vengono visualizzati come testo fantasma",
"inlineSuggest.enabled": "Controlla se visualizzare automaticamente i suggerimenti inline nell'Editor.",
"inlineSuggest.showToolbar": "Controlla quando mostrare la barra dei suggerimenti in linea.",
"inlineSuggest.showToolbar.always": "Mostra la barra degli strumenti dei suggerimenti in linea ogni volta che viene visualizzato un suggerimento in linea.",
"inlineSuggest.showToolbar.onHover": "Mostra la barra degli strumenti dei suggerimenti in linea quando al passaggio del mouse su un suggerimento in linea.",
"letterSpacing": "Controlla la spaziatura tra le lettere in pixel.",
"lineHeight": "Controlla l'altezza della riga. \r\n - Usare 0 per calcolare automaticamente l'altezza della riga dalle dimensioni del carattere.\r\n - I valori compresi tra 0 e 8 verranno usati come moltiplicatore con le dimensioni del carattere.\r\n - I valori maggiori o uguali a 8 verranno usati come valori effettivi.",
"lineNumbers": "Controlla la visualizzazione dei numeri di riga.",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "Controlla se la modifica collegata è abilitata per l'editor. A seconda del linguaggio, i simboli correlati, ad esempio i tag HTML, vengono aggiornati durante la modifica.",
"links": "Controlla se l'editor deve individuare i collegamenti e renderli selezionabili.",
"matchBrackets": "Evidenzia le parentesi graffe corrispondenti.",
"minimap.autohide": "Controlla se la minimappa viene nascosta automaticamente.",
"minimap.enabled": "Controlla se la minimappa è visualizzata.",
"minimap.maxColumn": "Limita la larghezza della minimappa in modo da eseguire il rendering al massimo di un certo numero di colonne.",
"minimap.renderCharacters": "Esegue il rendering dei caratteri effettivi di una riga in contrapposizione ai blocchi colore.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "La minimappa ha le stesse dimensioni del contenuto dell'editor (e potrebbe supportare lo scorrimento).",
"mouseWheelScrollSensitivity": "Moltiplicatore da usare sui valori `deltaX` e `deltaY` degli eventi di scorrimento della rotellina del mouse.",
"mouseWheelZoom": "Ingrandisce il carattere dell'editor quando si usa la rotellina del mouse e si tiene premuto 'CTRL'.",
"multiCursorLimit": "Controlla il numero massimo di cursori che possono essere presenti in un editor attivo contemporaneamente.",
"multiCursorMergeOverlapping": "Unire i cursori multipli se sovrapposti.",
"multiCursorModifier": "Modificatore da usare per aggiungere più cursori con il mouse. I gesti del mouse Vai alla definizione e Apri il collegamento si adatteranno in modo da non entrare in conflitto con il modificatore di selezione multipla. [Altre informazioni](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "Modificatore da usare per aggiungere più cursori con il mouse. I movimenti del mouse Vai alla definizione e Apri collegamento si adatteranno in modo da non entrare in conflitto con il [modificatore di selezione multipla](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier.alt": "Rappresenta il tasto 'Alt' in Windows e Linux e il tasto 'Opzione' in macOS.",
"multiCursorModifier.ctrlCmd": "Rappresenta il tasto 'Control' in Windows e Linux e il tasto 'Comando' in macOS.",
"multiCursorPaste": "Controlla l'operazione Incolla quando il conteggio delle righe del testo incollato corrisponde al conteggio dei cursori.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Controlla se spostare lo stato attivo sull'editor inline o sull'albero nel widget di anteprima.",
"peekWidgetDefaultFocus.editor": "Sposta lo stato attivo sull'editor quando si apre l'anteprima",
"peekWidgetDefaultFocus.tree": "Sposta lo stato attivo sull'albero quando si apre l'anteprima",
"quickSuggestions": "Controlla se visualizzare automaticamente i suggerimenti durante la digitazione.",
"quickSuggestions": "Controlla se i suggerimenti devono essere visualizzati automaticamente durante la digitazione. Può essere controllato per la digitazione in commenti, stringhe e altro codice. Il suggerimento rapido può essere configurato per essere visualizzato come testo fantasma o con il widget dei suggerimenti. Tenere anche conto dell'impostazione '{0}' che controlla se i suggerimenti vengono attivati dai caratteri speciali.",
"quickSuggestions.comments": "Abilita i suggerimenti rapidi all'interno di commenti.",
"quickSuggestions.other": "Abilita i suggerimenti rapidi all'esterno di stringhe e commenti.",
"quickSuggestions.strings": "Abilita i suggerimenti rapidi all'interno di stringhe.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Controlla se i controlli di riduzione sul margine della barra di scorrimento vengono visualizzati.",
"showFoldingControls.always": "Mostra sempre i comandi di riduzione.",
"showFoldingControls.mouseover": "Mostra i comandi di riduzione solo quando il mouse è posizionato sul margine della barra di scorrimento.",
"showFoldingControls.never": "Non visualizzare mai i controlli di riduzione e diminuire le dimensioni della barra di navigazione.",
"showUnused": "Controllo dissolvenza del codice inutilizzato.",
"smoothScrolling": "Controlla se per lo scorrimento dell'editor verrà usata un'animazione.",
"snippetSuggestions": "Controlla se i frammenti di codice sono visualizzati con altri suggerimenti e il modo in cui sono ordinati.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Emula il comportamento di selezione dei caratteri di tabulazione quando si usano gli spazi per il rientro. La selezione verrà applicata alle tabulazioni.",
"suggest.filterGraceful": "Controlla se i suggerimenti di filtro e ordinamento valgono per piccoli errori di battitura.",
"suggest.insertMode": "Controlla se le parole vengono sovrascritte quando si accettano i completamenti. Tenere presente che questa opzione dipende dalle estensioni che accettano esplicitamente questa funzionalità.",
"suggest.insertMode.always": "Selezionare sempre un suggerimento quando si attiva automaticamente IntelliSense.",
"suggest.insertMode.insert": "Inserisce il suggerimento senza sovrascrivere il testo a destra del cursore.",
"suggest.insertMode.never": "Non selezionare mai un suggerimento quando si attiva automaticamente IntelliSense.",
"suggest.insertMode.replace": "Inserisce il suggerimento e sovrascrive il testo a destra del cursore.",
"suggest.insertMode.whenQuickSuggestion": "Selezionare un suggerimento solo quando si attiva IntelliSense durante la digitazione.",
"suggest.insertMode.whenTriggerCharacter": "Selezionare un suggerimento solo quando si attiva IntelliSense da un carattere di trigger.",
"suggest.localityBonus": "Controlla se l'ordinamento privilegia le parole che appaiono più vicine al cursore.",
"suggest.maxVisibleSuggestions.dep": "Questa impostazione è deprecata. Il widget dei suggerimenti può ora essere ridimensionato.",
"suggest.preview": "Controlla se visualizzare in anteprima il risultato del suggerimento nell'Editor.",
"suggest.selectionMode": "Controlla se viene selezionato un suggerimento quando viene visualizzato il widget. Si noti che questo si applica solo ai suggerimenti attivati automaticamente ('#editor.quickSuggestions#' e '#editor.suggestOnTriggerCharacters#') e che un suggerimento viene sempre selezionato quando viene richiamato in modo esplicito, ad esempio tramite 'CTRL+BARRA SPAZIATRICE'.",
"suggest.shareSuggestSelections": "Controlla se condividere le selezioni dei suggerimenti memorizzati tra aree di lavoro e finestre (richiede `#editor.suggestSelection#`).",
"suggest.showIcons": "Controlla se mostrare o nascondere le icone nei suggerimenti.",
"suggest.showInlineDetails": "Controlla se i dettagli del suggerimento vengono visualizzati inline con l'etichetta o solo nel widget dei dettagli",
"suggest.showInlineDetails": "Controlla se i dettagli del suggerimento vengono visualizzati inline con l'etichetta o solo nel widget dei dettagli.",
"suggest.showStatusBar": "Controlla la visibilità della barra di stato nella parte inferiore del widget dei suggerimenti.",
"suggest.snippetsPreventQuickSuggestions": "Controlla se un frammento attivo impedisce i suggerimenti rapidi.",
"suggestFontSize": "Dimensioni del carattere per il widget dei suggerimenti. Se impostato su `0`, viene usato il valore di `#editor.fontSize#`.",
"suggestLineHeight": "Altezza della riga per il widget dei suggerimenti. Se impostato su `0`, viene usato il valore `editor.lineHeight#`. Il valore minimo è 8.",
"suggestFontSize": "Dimensioni del carattere per il widget dei suggerimenti. Se impostato su {0}, viene usato il valore di {1}.",
"suggestLineHeight": "Altezza della riga per il widget dei suggerimenti. Se impostato su {0}, viene usato il valore {1}. Il valore minimo è 8.",
"suggestOnTriggerCharacters": "Controlla se i suggerimenti devono essere visualizzati automaticamente durante la digitazione dei caratteri trigger.",
"suggestSelection": "Controlla la modalità di preselezione dei suggerimenti durante la visualizzazione dell'elenco dei suggerimenti.",
"suggestSelection.first": "Consente di selezionare sempre il primo suggerimento.",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Disabilita le funzionalità di completamento con tasto TAB.",
"tabCompletion.on": "La funzionalità di completamento con tasto TAB inserirà il migliore suggerimento alla pressione del tasto TAB.",
"tabCompletion.onlySnippets": "Completa i frammenti con il tasto TAB quando i rispettivi prefissi corrispondono. Funziona in modo ottimale quando 'quickSuggestions' non è abilitato.",
"tabFocusMode": "Controlla se l'editor riceve le schede o le rinvia al workbench per lo spostamento.",
"unfoldOnClickAfterEndOfLine": "Controlla se, facendo clic sul contenuto vuoto dopo una riga ridotta, la riga viene espansa.",
"unicodeHighlight.allowedCharacters": "Definisce i caratteri consentiti che non vengono evidenziati.",
"unicodeHighlight.allowedLocales": "I caratteri Unicode comuni nelle impostazioni locali consentite non vengono evidenziati.",
"unicodeHighlight.ambiguousCharacters": "Controlla se i caratteri che possono essere confusi con i caratteri ASCII di base sono evidenziati, ad eccezione di quelli comuni nelle impostazioni locali dell'utente corrente.",
"unicodeHighlight.includeComments": "Controlla se anche i caratteri nei commenti debbano essere soggetti a evidenziazione Unicode.",
"unicodeHighlight.includeStrings": "Controlla se anche i caratteri nelle stringhe devono essere soggetti all'evidenziazione unicode.",
"unicodeHighlight.includeComments": "Controlla se anche i caratteri nei commenti devono essere soggetti a evidenziazione Unicode.",
"unicodeHighlight.includeStrings": "Controlla se anche i caratteri nelle stringhe devono essere soggetti all'evidenziazione Unicode.",
"unicodeHighlight.invisibleCharacters": "Controlla se i caratteri che riservano spazio o non hanno larghezza sono evidenziati.",
"unicodeHighlight.nonBasicASCII": "Controlla se tutti i caratteri ASCII non di base sono evidenziati. Solo i caratteri compresi tra U+0020 e U+007E, tabulazione, avanzamento riga e ritorno a capo sono considerati ASCII di base.",
"unusualLineTerminators": "Rimuovi caratteri di terminazione di riga insoliti che potrebbero causare problemi.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "I caratteri di terminazione di riga insoliti vengono ignorati.",
"unusualLineTerminators.prompt": "Prompt per i caratteri di terminazione di riga insoliti da rimuovere.",
"useTabStops": "Inserimento ed eliminazione dello spazio vuoto dopo le tabulazioni.",
"wordBreak": "Controlla le regole di interruzione delle parole usate per il testo cinese/giapponese/coreano (CJK).",
"wordBreak.keepAll": "Le interruzioni di parola non devono essere usate per il testo cinese/giapponese/coreano (CJK). Il comportamento del testo non CJK è uguale a quello normale.",
"wordBreak.normal": "Usare la regola di interruzione di riga predefinita.",
"wordSeparators": "Caratteri che verranno usati come separatori di parola quando si eseguono operazioni o spostamenti correlati a parole.",
"wordWrap": "Controlla il ritorno a capo automatico delle righe.",
"wordWrap.bounded": "Il ritorno a capo automatico delle righe viene applicato in corrispondenza della larghezza minima del viewport e di `#editor.wordWrapColumn#`.",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "Le righe con ritorno a capo hanno un rientro di +1 rispetto alla riga padre.",
"wrappingIndent.none": "Nessun rientro. Le righe con ritorno a capo iniziano dalla colonna 1. ",
"wrappingIndent.same": "Le righe con ritorno a capo hanno lo stesso rientro della riga padre.",
"wrappingStrategy": "Controlla l'algoritmo che calcola i punti di ritorno a capo.",
"wrappingStrategy": "Controlla l'algoritmo che calcola i punti di wrapping. Si noti che quando è attiva la modalità di accessibilità, la modalità avanzata verrà usata per un'esperienza ottimale.",
"wrappingStrategy.advanced": "Delega il calcolo dei punti di ritorno a capo al browser. Si tratta di un algoritmo lento che potrebbe causare blocchi con file di grandi dimensioni, ma funziona correttamente in tutti gli altri casi.",
"wrappingStrategy.simple": "Presuppone che la larghezza sia identica per tutti caratteri. Si tratta di un algoritmo veloce che funziona correttamente per i tipi di carattere a spaziatura fissa e determinati script (come i caratteri latini) in cui i glifi hanno larghezza identica."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Colore di sfondo delle guide per coppie di parentesi inattive (6). Richiede l'abilitazione delle guide per coppie di parentesi.",
"editorCodeLensForeground": "Colore primo piano delle finestre di CodeLens dell'editor",
"editorCursorBackground": "Colore di sfondo del cursore editor. Permette di personalizzare il colore di un carattere quando sovrapposto da un blocco cursore.",
"editorDimmedLineNumber": "Colore della riga dell'editor finale quando editor.renderFinalNewline è impostato su in grigio.",
"editorGhostTextBackground": "Colore di sfondo del testo fantasma nell'editor.",
"editorGhostTextBorder": "Colore del bordo del testo fantasma nell'Editor.",
"editorGhostTextForeground": "Colore primo piano del testo fantasma nell'Editor.",
"editorGutter": "Colore di sfondo della barra di navigazione dell'editor. La barra contiene i margini di glifo e i numeri di riga.",
"editorIndentGuides": "Colore delle guide per i rientri dell'editor.",
"editorLineNumbers": "Colore dei numeri di riga dell'editor.",
"editorOverviewRulerBackground": "Colore di sfondo del righello delle annotazioni dell'editor. Viene usato solo quando la minimappa è abilitata e posizionata sul lato destro dell'editor.",
"editorOverviewRulerBackground": "Colore di sfondo del righello delle annotazioni dell'editor.",
"editorOverviewRulerBorder": "Colore del bordo del righello delle annotazioni.",
"editorRuler": "Colore dei righelli dell'editor.",
"editorUnicodeHighlight.background": "Colore di sfondo usato per evidenziare i caratteri Unicode.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Premere TAB nell'editor corrente per spostare lo stato attivo sull'elemento con stato attivabile successivo. Il comando {0} non può essere attualmente attivato con un tasto di scelta rapida.",
"toggleHighContrast": "Attiva/disattiva tema a contrasto elevato"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} caratteri",
"showMore": "Mostra di più ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Ancoraggio impostato alla posizione {0}:{1}",
"cancelSelectionAnchor": "Annulla ancoraggio della selezione",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Copia con nome",
"miCopy": "&&Copia",
"miCut": "&&Taglia",
"miPaste": "&&Incolla"
"miPaste": "&&Incolla",
"share": "Condividi"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Si è verificato un errore sconosciuto durante l'applicazione dell'azione del codice"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Si è verificato un errore sconosciuto durante l'applicazione dell'azione del codice",
"args.schema.apply": "Controlla quando vengono applicate le azioni restituite.",
"args.schema.apply.first": "Applica sempre la prima azione codice restituita.",
"args.schema.apply.ifSingle": "Applica la prima azione codice restituita se è l'unica.",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Organizza import",
"quickfix.trigger.label": "Correzione rapida...",
"refactor.label": "Effettua refactoring...",
"refactor.preview.label": "Refactoring con anteprima...",
"source.label": "Azione origine..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Abilita/disabilita la visualizzazione delle intestazioni gruppo nel menu Azione codice."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Riscrivi...",
"codeAction.widget.id.extract": "Estrai...",
"codeAction.widget.id.inline": "Inline...",
"codeAction.widget.id.more": "Altre azioni...",
"codeAction.widget.id.move": "Sposta...",
"codeAction.widget.id.quickfix": "Correzione rapida...",
"codeAction.widget.id.source": "Azione di origine...",
"codeAction.widget.id.surround": "Racchiudi con..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Nascondi elementi disabilitati",
"showMoreActions": "Mostra elementi disabilitati"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Mostra Azioni codice",
"codeActionWithKb": "Mostra Azioni codice ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "Attiva/Disattiva commento per la &&riga"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Mostra il menu di scelta rapida editor"
"action.showContextMenu.label": "Mostra il menu di scelta rapida editor",
"context.minimap.minimap": "Minimappa",
"context.minimap.renderCharacters": "Esegui rendering dei caratteri",
"context.minimap.size": "Dimensioni verticali",
"context.minimap.size.fill": "Riempimento",
"context.minimap.size.fit": "Adatta",
"context.minimap.size.proportional": "Proporzionale",
"context.minimap.slider": "Dispositivo di scorrimento",
"context.minimap.slider.always": "Sempre",
"context.minimap.slider.mouseover": "Passaggio del mouse"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Abilita/disabilita l'esecuzione delle modifiche dalle estensioni quando si incolla."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Esecuzione dei gestori Incolla in corso..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Cursore - Ripeti",
"cursor.undo": "Cursore - Annulla"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Esecuzione dei gestori di rilascio in corso..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Indica se l'editor esegue un'operazione annullabile, ad esempio 'Anteprima riferimenti'"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Esegue l'override del contrassegno \"Fai corrispondere maiuscole/minuscole\".\r\nIl contrassegno non verrà salvato per il futuro.\r\n0: Non eseguire alcuna operazione\r\n1: Vero\r\n2: Falso",
"actions.find.preserveCaseOverride": "Esegue l'override del contrassegno \"Mantieni maiuscole/minuscole\".\r\nIl contrassegno non verrà salvato per il futuro.\r\n0: Non eseguire alcuna operazione\r\n1: Vero\r\n2: Falso",
"actions.find.wholeWordOverride": "Esegue l'override del contrassegno \"Corrispondenza parola intera\".\r\nIl contrassegno non verrà salvato per il futuro.\r\n0: Non eseguire alcuna operazione\r\n1: Vero\r\n2: Falso",
"findMatchAction.goToMatch": "Andare a Corrispondenza...",
"findMatchAction.inputPlaceHolder": "Digitare un numero per passare a una corrispondenza specifica (tra 1 e {0})",
"findMatchAction.inputValidationMessage": "Digitare un numero compreso tra 1 e {0}",
"findNextMatchAction": "Trova successivo",
"findPreviousMatchAction": "Trova precedente",
"miFind": "&&Trova",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Solo i primi {0} risultati vengono evidenziati, ma tutte le operazioni di ricerca funzionano su tutto il testo."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Colore del controllo di riduzione nella barra di navigazione dell'editor.",
"createManualFoldRange.label": "Creare intervallo di riduzione dalla selezione",
"foldAction.label": "Riduci",
"foldAllAction.label": "Riduci tutto",
"foldAllBlockComments.label": "Riduci tutti i blocchi commento",
"foldAllExcept.label": "Riduci tutte le regioni eccetto quelle selezionate",
"foldAllMarkerRegions.label": "Riduci tutte le regioni",
"foldBackgroundBackground": "Colore di sfondo degli intervalli con riduzione. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"foldLevelAction.label": "Livello riduzione {0}",
"foldRecursivelyAction.label": "Riduci in modo ricorsivo",
"gotoNextFold.label": "Passa all'intervallo di riduzione successivo",
"gotoParentFold.label": "Vai alla cartella principale",
"gotoPreviousFold.label": "Passa all'intervallo di riduzione precedente",
"maximum fold ranges": "Il numero di aree riducibili è limitato a un massimo di {0}. Aumentare l'opzione di configurazione ['Numero massimo di aree riducibili'](command:workbench.action.openSettings?[\" editor.foldingMaximumRegions\"]) per abilitarne altre.",
"removeManualFoldingRanges.label": "Rimuovi intervalli di riduzione manuale",
"toggleFoldAction.label": "Attiva/Disattiva riduzione",
"unFoldRecursivelyAction.label": "Espandi in modo ricorsivo",
"unfoldAction.label": "Espandi",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Espandi tutte le regioni"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Colore del controllo di riduzione nella barra di navigazione dell'editor.",
"foldBackgroundBackground": "Colore di sfondo degli intervalli con riduzione. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"foldingCollapsedIcon": "Icona per gli intervalli compressi nel margine del glifo dell'editor.",
"foldingExpandedIcon": "Icona per gli intervalli espansi nel margine del glifo dell'editor."
"foldingExpandedIcon": "Icona per gli intervalli espansi nel margine del glifo dell'editor.",
"foldingManualCollapedIcon": "Icona per gli intervalli compressi nel margine del glifo dell'editor.",
"foldingManualExpandedIcon": "Icona per gli intervalli espansi manualmente nel margine del glifo dell'editor."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Zoom avanti tipo di carattere editor",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Caricamento...",
"stopped rendering": "Rendering sospeso per una linea lunga per motivi di prestazioni. Può essere configurato tramite 'editor.stopRenderingLineAfter'.",
"too many characters": "Per motivi di prestazioni la tokenizzazione viene ignorata per le righe lunghe. È possibile effettuare questa configurazione tramite `editor.maxTokenizationLineLength`."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Visualizza problema"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Modifica dimensioni visualizzazione scheda",
"configuredTabSize": "Dimensione tabulazione configurata",
"currentTabSize": "Dimensioni della scheda corrente",
"defaultTabSize": "Dimensioni predefinite della scheda",
"detectIndentation": "Rileva rientro dal contenuto",
"editor.reindentlines": "Imposta nuovo rientro per righe",
"editor.reindentselectedlines": "Re-Indenta le Linee Selezionate",
@ -864,7 +977,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/inlayHints/browser/inlayHintsHover": {
"hint.cmd": "Esegui il comando",
"hint.dbl": "Fai doppio clic per inserire",
"hint.dbl": "Fare doppio clic per inserire",
"hint.def": "Vai alla definizione ({0})",
"hint.defAndCommand": "Vai alla definizione ({0}), fai clic con il pulsante destro del mouse per altre informazioni",
"links.navigate.kb.alt": "ALT+clic",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "CMD+clic"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Accetta",
"acceptWord": "Accetta parola",
"action.inlineSuggest.accept": "Accetta il suggerimento in linea",
"action.inlineSuggest.acceptNextWord": "Accettare suggerimento inline per la parola successiva",
"action.inlineSuggest.alwaysShowToolbar": "Mostra sempre la barra degli strumenti",
"action.inlineSuggest.hide": "Nascondi suggerimento inline",
"action.inlineSuggest.showNext": "Mostrare suggerimento inline successivo",
"action.inlineSuggest.showPrevious": "Mostrare suggerimento inline precedente",
"action.inlineSuggest.trigger": "Trigger del suggerimento inline",
"action.inlineSuggest.undo": "Annullare Accetta parola",
"alwaysShowInlineSuggestionToolbar": "Indica se la barra degli strumenti dei suggerimenti in linea deve essere sempre visibile",
"canUndoInlineSuggestion": "Indica se l'annullamento annullerebbe un suggerimento inline",
"inlineSuggestionHasIndentation": "Se il suggerimento in linea inizia con spazi vuoti",
"inlineSuggestionHasIndentationLessThanTabSize": "Indica se il suggerimento inline inizia con uno spazio vuoto minore di quello che verrebbe inserito dalla tabulazione",
"inlineSuggestionVisible": "Se è visibile un suggerimento inline"
"inlineSuggestionVisible": "Se è visibile un suggerimento inline",
"undoAcceptWord": "Annulla Accetta parola"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Suggerimento:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Avanti",
"parameterHintsNextIcon": "Icona per visualizzare il suggerimento del parametro successivo.",
"parameterHintsPreviousIcon": "Icona per visualizzare il suggerimento del parametro precedente.",
"previous": "Indietro"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Sostituisci con il valore successivo",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Duplica selezione",
"editor.transformToCamelcase": "Trasforma in caso Camel",
"editor.transformToKebabcase": "Trasformare in caso Kebab",
"editor.transformToLowercase": "Converti in minuscolo",
"editor.transformToSnakecase": "Trasforma in snake case",
"editor.transformToTitlecase": "Trasforma in Tutte Iniziali Maiuscole",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Esegue il comando {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Non è possibile modificare nell'editor di sola lettura",
"messageVisible": "Indica se l'editor visualizza attualmente un messaggio inline"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Sposta ultima selezione a risultato ricerca precedente",
"mutlicursor.addCursorsToBottom": "Aggiungi cursori alla fine",
"mutlicursor.addCursorsToTop": "Aggiungi cursori all'inizio",
"mutlicursor.focusNextCursor": "Attival cursore successivo",
"mutlicursor.focusNextCursor.description": "Attiva il cursore successivo",
"mutlicursor.focusPreviousCursor": "Cursore precedente stato attivo",
"mutlicursor.focusPreviousCursor.description": "Imposta lo stato attivo sul cursore precedente",
"mutlicursor.insertAbove": "Aggiungi cursore sopra",
"mutlicursor.insertAtEndOfEachLineSelected": "Aggiungi cursori a fine riga",
"mutlicursor.insertBelow": "Aggiungi cursore sotto",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Colore di sfondo della barra di navigazione nell'editor visualizzazione rapida.",
"peekViewEditorMatchHighlight": "Colore dell'evidenziazione delle corrispondenze nell'editor di visualizzazioni rapide.",
"peekViewEditorMatchHighlightBorder": "Bordo dell'evidenziazione delle corrispondenze nell'editor di visualizzazioni rapide.",
"peekViewEditorStickScrollBackground": "Colore di sfondo della barra di scorrimento permanente nell'editor visualizzazione rapida.",
"peekViewResultsBackground": "Colore di sfondo dell'elenco risultati della visualizzazione rapida.",
"peekViewResultsFileForeground": "Colore primo piano dei nodi file nell'elenco risultati della visualizzazione rapida.",
"peekViewResultsMatchForeground": "Colore primo piano dei nodi riga nell'elenco risultati della visualizzazione rapida.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "parametri di tipo ({0})",
"variable": "variabili ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Non è possibile modificare nell'editor di sola lettura",
"editor.simple.readonly": "Non è possibile modificare nell'input di sola lettura"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "Correttamente rinominato '{0}' in '{1}'. Sommario: {2}",
"enablePreview": "Abilita/Disabilita l'opzione per visualizzare le modifiche in anteprima prima della ridenominazione",
"label": "Ridenominazione di '{0}'",
"label": "Ridenominazione di '{0}' in '{1}'",
"no result": "Nessun risultato.",
"quotableLabel": "Ridenominazione di {0}",
"quotableLabel": "Ridenominazione di {0} in {1}",
"rename.failed": "La ridenominazione non è riuscita a calcolare le modifiche",
"rename.failedApply": "La ridenominazione non è riuscita ad applicare le modifiche",
"rename.label": "Rinomina simbolo",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Indica se è presente una tabulazione successiva in modalità frammenti",
"hasPrevTabstop": "Indica se è presente una tabulazione precedente in modalità frammenti",
"inSnippetMode": "Indica se l'editor è quello corrente nella modalità frammenti"
"inSnippetMode": "Indica se l'editor è quello corrente nella modalità frammenti",
"next": "Vai al segnaposto successivo..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Aprile",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Mercoledì",
"WednesdayShort": "Mer"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Scorrimento permanente",
"mitoggleStickyScroll": "&&Alternanza scorrimento permanente",
"stickyScroll": "Scorrimento permanente",
"toggleStickyScroll": "Alternanza scorrimento permanente"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Indica se i suggerimenti vengono inseriti quando si preme INVIO",
"suggestWidgetDetailsVisible": "Indica se i dettagli dei suggerimenti sono visibili",
"suggestWidgetHasSelection": "Indica se i suggerimenti sono evidenziati",
"suggestWidgetMultipleSuggestions": "Indica se sono presenti più suggerimenti da cui scegliere",
"suggestionCanResolve": "Indica se il suggerimento corrente supporta la risoluzione di ulteriori dettagli",
"suggestionHasInsertAndReplaceRange": "Indica se il suggerimento corrente include il comportamento di inserimento e sostituzione",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Icona per visualizzare altre informazioni nel widget dei suggerimenti."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Colore primo piano per i simboli di matrice. Questi simboli vengono visualizzati nella struttura, nell'elemento di navigazione e nel widget dei suggerimenti.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "Il file \"\r\n\" contiene uno o più caratteri di terminazione di riga insoliti, ad esempio separatore di riga (LS) o separatore di paragrafo (PS).{0}\r\nÈ consigliabile rimuoverli dal file. È possibile configurare questa opzione tramite `editor.unusualLineTerminators`.",
"unusualLineTerminators.fix": "Rimuovi i caratteri di terminazione di riga insoliti",
"unusualLineTerminators.fix": "&&Rimuovi i caratteri di terminazione di riga insoliti",
"unusualLineTerminators.ignore": "Ignora",
"unusualLineTerminators.message": "Sono stati rilevati caratteri di terminazione di riga insoliti",
"unusualLineTerminators.title": "Caratteri di terminazione di riga insoliti"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Colore del marcatore del righello delle annotazioni per le evidenziazioni dei simboli. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"overviewRulerWordHighlightStrongForeground": "Colore del marcatore del righello delle annotazioni per le evidenziazioni dei simboli di accesso in scrittura. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"overviewRulerWordHighlightTextForeground": "Colore del marcatore del righello delle annotazioni di un'occorrenza testuale per un simbolo. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"wordHighlight": "Colore di sfondo di un simbolo durante l'accesso in lettura, ad esempio durante la lettura di una variabile. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"wordHighlight.next.label": "Vai al prossimo simbolo evidenziato",
"wordHighlight.previous.label": "Vai al precedente simbolo evidenziato",
"wordHighlight.trigger.label": "Attiva/disattiva evidenziazione simbolo",
"wordHighlightBorder": "Colore del bordo di un simbolo durante l'accesso in lettura, ad esempio durante la lettura di una variabile.",
"wordHighlightStrong": "Colore di sfondo di un simbolo durante l'accesso in scrittura, ad esempio durante la scrittura in una variabile. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"wordHighlightStrongBorder": "Colore del bordo di un simbolo durante l'accesso in scrittura, ad esempio durante la scrittura in una variabile."
"wordHighlightStrongBorder": "Colore del bordo di un simbolo durante l'accesso in scrittura, ad esempio durante la scrittura in una variabile.",
"wordHighlightText": "Colore di sfondo di un'occorrenza testuale per un simbolo. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"wordHighlightTextBorder": "Colore del bordo di un'occorrenza testuale per un simbolo."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Vai al prossimo simbolo evidenziato",
"wordHighlight.previous.label": "Vai al precedente simbolo evidenziato",
"wordHighlight.trigger.label": "Attiva/disattiva evidenziazione simbolo"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Elimina parola"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Sviluppatore",
"help": "Guida",
"preferences": "Preferenze",
"test": "Test",
"view": "Visualizza"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Nascondi",
"resetThisMenu": "Reimposta menu"
},
"vs/platform/actions/common/menuService": {
"hide.label": "Nascondi '{0}'"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Widget azione",
"customQuickFixWidget.labels": "{0}, Motivo disabilitato: {1}",
"label": "{0} da applicare",
"label-preview": "{0} per Applica, {1} per Anteprima"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Accetta l'azione selezionata",
"codeActionMenuVisible": "Indica se l'elenco di widget azione è visibile",
"hideCodeActionWidget.title": "Nascondi widget azione",
"previewSelected.title": "Anteprima azione selezionata",
"selectNextCodeAction.title": "Seleziona azione successiva",
"selectPrevCodeAction.title": "Seleziona azione precedente"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Riga diff eliminata",
"audioCues.diffLineInserted": "Riga diff inserita",
"audioCues.diffLineModified": "Riga diff modificata",
"audioCues.lineHasBreakpoint.name": "Punto di interruzione sulla riga",
"audioCues.lineHasError.name": "Errore sulla riga",
"audioCues.lineHasFoldedArea.name": "Area piegata sulla linea",
"audioCues.lineHasInlineSuggestion.name": "Suggerimento inline sulla riga",
"audioCues.lineHasWarning.name": "Avviso sulla riga",
"audioCues.noInlayHints": "Nessun suggerimento per l'inlay nella riga",
"audioCues.notebookCellCompleted": "Cella del notebook completata",
"audioCues.notebookCellFailed": "La cella del notebook ha avuto esito negativo",
"audioCues.onDebugBreak.name": "Debugger arrestato sul punto di interruzione",
"audioCues.taskCompleted": "Attività completata",
"audioCues.taskFailed": "Attività non riuscita",
"audioCues.terminalBell": "Campanello terminale",
"audioCues.terminalCommandFailed": "Comando terminale non riuscito",
"audioCues.terminalQuickFix.name": "Correzione rapida terminale"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "Impossibile registrare '{0}'. Il {1} dei criteri associato è già registrato con {2}.",
"config.property.duplicate": "Non è possibile registrare '{0}'. Questa proprietà è già registrata.",
"config.property.empty": "Non è possibile registrare una proprietà vuota",
"config.property.languageDefault": "Non è possibile registrare '{0}'. Corrisponde al criterio di proprietà '\\\\[.*\\\\]$' per la descrizione delle impostazioni dell'editor specifiche del linguaggio. Usare il contributo 'configurationDefaults'.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Indica se il sistema operativo è Linux",
"isMac": "Indica se il sistema operativo è macOS",
"isMacNative": "Indica se il sistema operativo è macOS in una piattaforma non basata su browser",
"isMobile": "Indica se la piattaforma è un Web browser per dispositivi mobili",
"isWeb": "Indica se la piattaforma è un Web browser",
"isWindows": "Indica se il sistema operativo è Windows"
"isWindows": "Indica se il sistema operativo è Windows",
"productQualityType": "Tipo di qualità del VS Code"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Annulla",
"moreFile": "...1 altro file non visualizzato",
"moreFiles": "...{0} altri file non visualizzati"
"moreFiles": "...{0} altri file non visualizzati",
"okButton": "&&OK",
"yesButton": "&&Sì"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "Il file è troppo grande per essere aperto come editor senza titolo. Caricarlo prima in Esplora file, quindi riprovare."
},
"vs/platform/files/common/files": {
"sizeB": "{0} B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Moltiplicatore della velocità di scorrimento quando si preme `Alt`.",
"Mouse Wheel Scroll Sensitivity": "Moltiplicatore da usare sui valori `deltaX` e `deltaY` degli eventi di scorrimento della rotellina del mouse.",
"automatic keyboard navigation setting": "Controlla se gli spostamenti da tastiera per elenchi e alberi vengono attivati semplicemente premendo un tasto. Se è impostato su `false`, gli spostamenti da tastiera vengono attivati solo durante l'esecuzione del comando `list.toggleKeyboardNavigation`, al quale è possibile assegnare un tasto di scelta rapida.",
"defaultFindMatchTypeSettingKey": "Controlla il tipo di corrispondenza usato per la ricerca di elenchi e alberi nel workbench.",
"defaultFindMatchTypeSettingKey.contiguous": "Usa corrispondenza contigua durante la ricerca.",
"defaultFindMatchTypeSettingKey.fuzzy": "Usa la corrispondenza fuzzy durante la ricerca.",
"defaultFindModeSettingKey": "Controlla la modalità di ricerca predefinita per elenchi e alberi nel workbench.",
"defaultFindModeSettingKey.filter": "Filtra gli elementi durante la ricerca.",
"defaultFindModeSettingKey.highlight": "Evidenziare gli elementi durante la ricerca. L'ulteriore spostamento verso l'alto e verso il basso attraverserà solo gli elementi evidenziati.",
"expand mode": "Controlla l'espansione delle cartelle di alberi quando si fa clic sui nomi delle cartelle. Tenere presente che alcuni alberi ed elenchi potrebbero scegliere di ignorare questa impostazione se non è applicabile.",
"horizontalScrolling setting": "Controlla se elenchi e alberi supportano lo scorrimento orizzontale nell'area di lavoro. Avviso: l'attivazione di questa impostazione può influire sulle prestazioni.",
"keyboardNavigationSettingKey": "Controlla lo stile di spostamento da tastiera per elenchi e alberi nel workbench. Le opzioni sono: simple, highlight e filter.",
"keyboardNavigationSettingKey.filter": "Con lo stile di spostamento da tastiera filter verranno filtrati e nascosti tutti gli elementi che non corrispondono all'input da tastiera.",
"keyboardNavigationSettingKey.highlight": "Con lo stile di spostamento da tastiera highlight vengono evidenziati gli elementi corrispondenti all'input da tastiera. Spostandosi ulteriormente verso l'alto o verso il basso ci si sposterà solo negli elementi evidenziati.",
"keyboardNavigationSettingKey.simple": "Con lo stile di spostamento da tastiera simple lo stato attivo si trova sugli elementi che corrispondono all'input da tastiera. L'abbinamento viene effettuato solo in base ai prefissi.",
"keyboardNavigationSettingKeyDeprecated": "In alternativa, usare 'workbench.list.defaultFindMode' e 'workbench.list.typeNavigationMode'.",
"list smoothScrolling setting": "Controlla se elenchi e alberi prevedono lo scorrimento uniforme.",
"list.scrollByPage": "Controlla se i clic nella barra di scorrimento scorrono pagina per pagina.",
"multiSelectModifier": "Il modificatore da utilizzare per aggiungere un elemento di alberi e liste ad una selezione multipla con il mouse (ad esempio in Esplora Risorse, apre gli editor e le viste scm). Le gesture del mouse 'Apri a lato' - se supportate - si adatteranno in modo da non creare conflitti con il modificatore di selezione multipla.",
"multiSelectModifier.alt": "Rappresenta il tasto 'Alt' in Windows e Linux e il tasto 'Opzione' in macOS.",
"multiSelectModifier.ctrlCmd": "Rappresenta il tasto 'Control' in Windows e Linux e il tasto 'Comando' in macOS.",
"openModeModifier": "Controlla l'apertura degli elementi di alberi ed elenchi tramite il mouse (se supportato). Tenere presente che alcuni alberi ed elenchi potrebbero scegliere di ignorare questa impostazione se non è applicabile.",
"render tree indent guides": "Controlla se l'albero deve eseguire il rendering delle guide per i rientri.",
"tree indent setting": "Controlla il rientro dell'albero in pixel.",
"typeNavigationMode": "Controllare il funzionamento dello spostamento dei tipi in elenchi e alberi nel workbench. Se impostato su 'trigger', l'esplorazione del tipo inizia dopo l'esecuzione del comando 'list.triggerTypeNavigation'.",
"workbenchConfigurationTitle": "Workbench"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Avviso"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "Il comando '{0}' ha restituito un errore ({1})",
"canNotRun": "Il comando '{0}' ha restituito un errore",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "più usato",
"morecCommands": "altri comandi",
"recentlyUsed": "usate di recente"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "comandi dell'editor",
"globalCommands": "comandi globali",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Personalizzato",
"inputModeEntry": "Premere 'INVIO' per confermare l'input oppure 'ESC' per annullare",
"inputModeEntryDescription": "{0} (premere 'INVIO' per confermare oppure 'ESC' per annullare)",
"ok": "OK",
"quickInput.back": "Indietro",
"quickInput.backWithKeybinding": "Indietro ({0})",
"quickInput.checkAll": "Attivare/Disattivare tutte le caselle di controllo",
"quickInput.countSelected": "{0} selezionati",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} risultati",
"quickInputBox.ariaLabel": "Digitare per ridurre il numero di risultati."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Input rapido"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Fare clic per eseguire il comando '{0}'"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Un bordo supplementare intorno agli elementi attivi per contrastarli maggiormente rispetto agli altri.",
"activeLinkForeground": "Colore dei collegamenti attivi.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Colore di sfondo degli elementi di navigazione.",
"breadcrumbsFocusForeground": "Colore degli elementi di navigazione in evidenza.",
"breadcrumbsSelectedBackground": "Colore di sfondo del controllo di selezione elementi di navigazione.",
"breadcrumbsSelectedForegound": "Colore degli elementi di navigazione selezionati.",
"breadcrumbsSelectedForeground": "Colore degli elementi di navigazione selezionati.",
"buttonBackground": "Colore di sfondo del pulsante.",
"buttonBorder": "Colore del bordo del pulsante.",
"buttonForeground": "Colore primo piano del pulsante.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Colore di sfondo secondario del pulsante.",
"buttonSecondaryForeground": "Colore primo piano secondario del pulsante.",
"buttonSecondaryHoverBackground": "Colore di sfondo secondario del pulsante al passaggio del mouse.",
"buttonSeparator": "Colore del separatore pulsante.",
"chartsBlue": "Colore blu usato nelle visualizzazioni grafico.",
"chartsForeground": "Colore primo piano usato nei grafici.",
"chartsGreen": "Colore verde usato nelle visualizzazioni grafico.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Colore di sfondo del widget della casella di controllo.",
"checkbox.border": "Colore del bordo del widget della casella di controllo.",
"checkbox.foreground": "Colore primo piano del widget della casella di controllo.",
"checkbox.select.background": "Colore di sfondo del widget della casella di controllo quando è selezionato l'elemento in cui si trova.",
"checkbox.select.border": "Colore del bordo del widget della casella di controllo quando è selezionato l'elemento in cui si trova.",
"contrastBorder": "Un bordo supplementare attorno agli elementi per contrastarli maggiormente rispetto agli altri.",
"descriptionForeground": "Colore primo piano del testo che fornisce informazioni aggiuntive, ad esempio per un'etichetta di testo.",
"diffDiagonalFill": "Colore del riempimento diagonale dell'editor diff. Il riempimento diagonale viene usato nelle visualizzazioni diff affiancate.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Colore di sfondo per il margine in cui sono state rimosse le righe.",
"diffEditorRemovedLines": "Colore di sfondo per le righe che sono state rimosse. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"diffEditorRemovedOutline": "Colore del contorno del testo che è stato rimosso.",
"disabledForeground": "Primo piano generale per gli elementi disabilitati. Questo colore viene usato solo e non è sostituito da quello di un componente.",
"dropdownBackground": "Sfondo dell'elenco a discesa.",
"dropdownBorder": "Bordo dell'elenco a discesa.",
"dropdownForeground": "Primo piano dell'elenco a discesa.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Colore del testo selezionato per il contrasto elevato.",
"editorSelectionHighlight": "Colore delle aree con lo stesso contenuto della selezione. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"editorSelectionHighlightBorder": "Colore del bordo delle regioni con lo stesso contenuto della selezione.",
"editorStickyScrollBackground": "Colore di sfondo dello scorrimento permanente per l'editor",
"editorStickyScrollHoverBackground": "Colore di sfondo dello scorrimento permanente al passaggio del mouse per l'editor",
"editorWarning.background": "Colore di sfondo del testo dell'avviso nell'editor. Il colore non deve essere opaco per evitare di nascondere le decorazioni sottostanti.",
"editorWarning.foreground": "Colore primo piano degli indicatori di avviso nell'editor.",
"editorWidgetBackground": "Colore di sfondo dei widget dell'editor, ad esempio Trova/Sostituisci.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Colore di sfondo del widget del filtro per tipo in elenchi e alberi.",
"listFilterWidgetNoMatchesOutline": "Colore del contorno del widget del filtro per tipo in elenchi e alberi quando non sono presenti corrispondenze.",
"listFilterWidgetOutline": "Colore del contorno del widget del filtro per tipo in elenchi e alberi.",
"listFilterWidgetShadow": "Colore ombreggiatura del widget del filtro in elenchi e alberi.",
"listFocusAndSelectionOutline": "Colore del contorno dell'elenco/albero per l'elemento con lo stato attivo quando l'elenco/albero è attivo e selezionato. Un elenco/albero attivo ha lo stato attivo della tastiera, a differenza di uno inattivo.",
"listFocusBackground": "Colore di sfondo dell'elenco/albero per l'elemento con lo stato attivo quando l'elenco/albero è attivo. Un elenco/albero attivo ha lo stato attivo della tastiera, a differenza di uno inattivo.",
"listFocusForeground": "Colore primo piano dell'elenco/albero per l'elemento con lo stato attivo quando l'elenco/albero è attivo. Un elenco/albero attivo ha lo stato attivo della tastiera, a differenza di uno inattivo.",
"listFocusHighlightForeground": "Colore primo piano Elenco/Struttura ad albero delle occorrenze trovate in elementi con lo stato attivo durante la ricerca nell'Elenco/Struttura ad albero.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Sfondo della barra degli strumenti quando si tiene premuto il mouse sulle azioni",
"toolbarHoverBackground": "Sfondo della barra degli strumenti al passaggio del mouse sulle azioni",
"toolbarHoverOutline": "Contorno della barra degli strumenti al passaggio del mouse sulle azioni",
"treeInactiveIndentGuidesStroke": "Colore del tratto dell'albero per le guide di rientro non attive.",
"treeIndentGuidesStroke": "Colore del tratto dell'albero per le guide per i rientri.",
"warningBorder": "Colore del bordo delle caselle di avviso nell'editor.",
"widgetBorder": "Colore del bordo dei widget, ad es. Trova/Sostituisci all'interno dell'editor.",
"widgetShadow": "Colore ombreggiatura dei widget, ad es. Trova/Sostituisci all'interno dell'editor."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Icona dell'azione di chiusura nei widget."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Annulla",
"cannotResourceRedoDueToInProgressUndoRedo": "Non è stato possibile ripetere '{0}' perché è già in esecuzione un'operazione di annullamento o ripetizione.",
"cannotResourceUndoDueToInProgressUndoRedo": "Non è stato possibile annullare '{0}' perché è già in esecuzione un'operazione di annullamento o ripetizione.",
"cannotWorkspaceRedo": "Non è stato possibile ripetere '{0}' in tutti i file. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "Non è stato possibile annullare '{0}' su tutti i file perché è già in esecuzione un'operazione di annullamento o ripetizione su {1}",
"confirmDifferentSource": "Annullare '{0}'?",
"confirmDifferentSource.no": "No",
"confirmDifferentSource.yes": "Sì",
"confirmDifferentSource.yes": "&&Sì",
"confirmWorkspace": "Annullare '{0}' in tutti i file?",
"externalRemoval": "I file seguenti sono stati chiusi e modificati nel disco: {0}.",
"noParallelUniverses": "I file seguenti sono stati modificati in modo incompatibile: {0}.",
"nok": "Annulla questo file",
"ok": "Annulla in {0} file"
"nok": "Annulla questo &&file",
"ok": "&&Annulla in {0} file"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Area di lavoro del codice"

426
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/ja.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "その他の操作..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "ダイアログを閉じる",
"dialogErrorMessage": "エラー",
"dialogInfoMessage": "情報",
"dialogPendingMessage": "進行中",
"dialogWarningMessage": "警告",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "その他の操作..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "入力"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "大文字と小文字を区別する",
"regexDescription": "正規表現を使用する",
"wordsDescription": "単語単位で検索する"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "入力",
"label.preserveCaseToggle": "保持する"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "バインドなし"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "ボックスを選択"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "その他の操作..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "クリア",
"disable filter on type": "型のフィルターを無効にする",
"empty": "要素が見つかりません",
"enable filter on type": "型のフィルターを有効にする",
"found": "{1} 個の要素のうち {0} 個の要素が一致しました"
"close": "閉じる",
"filter": "フィルター",
"fuzzySearch": "あいまい一致",
"not found": "要素が見つかりません。",
"type to filter": "入力してフィルター",
"type to search": "入力して検索"
},
"vs/base/common/actions": {
"submenu.empty": "(空)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "カスタム",
"inputModeEntry": "'Enter' を押して入力を確認するか 'Escape' を押して取り消します",
"inputModeEntryDescription": "{0} ('Enter' を押して確認するか 'Escape' を押して取り消します)",
"ok": "OK",
"quickInput.back": "戻る",
"quickInput.backWithKeybinding": "戻る ({0})",
"quickInput.countSelected": "{0} 個選択済み",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} 件の結果",
"quickInputBox.ariaLabel": "入力すると結果が絞り込まれます。"
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "クイック入力"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "この時点では、エディターにアクセスできません。オプションを表示するには、{0} を押します。",
@ -86,12 +100,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "元に戻す"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "カーソルの数は {0} 個に制限されています。"
"cursors.maximum": "カーソルの数は {0} に制限されています。大きな変更を行う場合は、[検索と置換](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) を使用することを検討してください。",
"goToSetting": "マルチ カーソルの上限を増やす"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " Shift + F7 を使用して変更を移動する",
"diff.tooLarge": "一方のファイルが大きすぎるため、ファイルを比較できません。",
"diffInsertIcon": "差分エディターで挿入を示す線の装飾。",
"diffRemoveIcon": "差分エディターで削除を示す線の装飾。"
"diffInsertIcon": "差分エディターで挿入を示す行の装飾。",
"diffRemoveIcon": "差分エディターで削除を示す行の装飾。"
},
"vs/editor/browser/widget/diffReview": {
"blankLine": "空白",
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "エディターで CodeLens を表示するかどうかを制御します。",
"detectIndentation": "ファイルがファイルの内容に基づいて開かれる場合、`#editor.tabSize#` と `#editor.insertSpaces#` を自動的に検出するかどうかを制御します。",
"detectIndentation": "ファイルがファイルの内容に基づいて開かれる場合、{0} と {1} を自動的に検出するかどうかを制御します。",
"diffAlgorithm.experimental": "試験的な差分アルゴリズムを使用します。",
"diffAlgorithm.smart": "既定の差分アルゴリズムを使用します。",
"editor.experimental.asyncTokenization": "Web ワーカーでトークン化を非同期的に行うかどうかを制御します。",
"editorConfigurationTitle": "エディター",
"ignoreTrimWhitespace": "有効にすると、差分エディターは先頭または末尾の空白文字の変更を無視します。",
"insertSpaces": "`Tab` キーを押すとスペースが挿入されます。`#editor.detectIndentation#` がオンの場合、この設定はファイル コンテンツに基づいて上書きされます。",
"indentSize": "インデントまたは `\"tabSize\"` で `#editor.tabSize#` の値を使用するために使用されるスペースの数。この設定は、 `#editor.detectIndentation#` がオンの場合、ファイルの内容に基づいてオーバーライドされます。",
"insertSpaces": "`Tab` キーを押すとスペースが挿入されます。{0} がオンの場合、この設定はファイル コンテンツに基づいて上書きされます。",
"largeFileOptimizations": "大きなファイルでメモリが集中する特定の機能を無効にするための特別な処理。",
"maxComputationTime": "差分計算が取り消された後のタイムアウト (ミリ秒単位)。タイムアウトなしには 0 を使用します。",
"maxFileSize": "差分を計算する場合の最大ファイル サイズ (MB)。制限なしの場合は 0 を使用します。",
"maxTokenizationLineLength": "この長さを越える行は、パフォーマンス上の理由によりトークン化されません。",
"renderIndicators": "差分エディターが追加/削除された変更に +/- インジケーターを示すかどうかを制御します。",
"renderMarginRevertIcon": "有効にすると、差分エディターでグリフ余白に、変更を元に戻すための矢印が表示されます。",
"schema.brackets": "インデントを増減する角かっこを定義します。",
"schema.closeBracket": "右角かっこまたは文字列シーケンス。",
"schema.colorizedBracketPairs": "角かっこのペアの色付けが有効になっている場合、入れ子のレベルによって色付けされる角かっこのペアを定義します。",
@ -140,14 +161,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.true": "セマンティックの強調表示がすべての配色テーマについて有効になりました。",
"sideBySide": "差分エディターが差分を横に並べて表示するか、行内に表示するかを制御します。",
"stablePeek": "エディターのコンテンツをダブルクリックするか、`Escape` キーを押しても、ピーク エディターを開いたままにします。",
"tabSize": "1 つのタブに相当するスペースの数。`#editor.detectIndentation#` がオンの場合、この設定はファイル コンテンツに基づいて上書きされます。",
"tabSize": "1 つのタブに相当するスペースの数。{0} がオンの場合、この設定はファイル コンテンツに基づいて上書きされます。",
"trimAutoWhitespace": "自動挿入された末尾の空白を削除します。",
"wordBasedSuggestions": "ドキュメント内の単語に基づいて入力候補を計算するかどうかを制御します。",
"wordBasedSuggestionsMode": "単語ベースの入力候補が計算されるドキュメントを制御します。",
"wordBasedSuggestionsMode.allDocuments": "開いているすべてのドキュメントから単語の候補を表示します。",
"wordBasedSuggestionsMode.currentDocument": "アクティブなドキュメントからのみ単語の候補を表示します。",
"wordBasedSuggestionsMode.matchingDocuments": "同じ言語の開いているすべてのドキュメントから単語の候補を表示します。",
"wordWrap.inherit": "行は、`#editor.wordWrap#` 設定に従って折り返されます。",
"wordWrap.inherit": "行は、{0} の設定に従って折り返されます。",
"wordWrap.off": "行を折り返しません。",
"wordWrap.on": "行をビューポートの幅で折り返します。"
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "`Tab` キーに加えて `Enter` キーで候補を受け入れるかどうかを制御します。改行の挿入や候補の反映の間であいまいさを解消するのに役立ちます。",
"acceptSuggestionOnEnterSmart": "テキストの変更を行うとき、`Enter` を使用する場合にのみ候補を受け付けます。",
"accessibilityPageSize": "一度にスクリーン リーダーによって読み上げることができるエディターの行数を制御します。スクリーン リーダーが検出されると、既定値が 500 に自動的に設定されます。警告: 既定値より大きい数値の場合は、パフォーマンスに影響があります。",
"accessibilitySupport": "エディターをスクリーン リーダーに最適化されたモードで実行するかどうかを制御します。オンに設定すると単語の折り返しが無効になります。",
"accessibilitySupport.auto": "エディターはスクリーン リーダーがいつ接続されたかを検出するためにプラットフォーム API を使用します。",
"accessibilitySupport.off": "エディターはスクリーン リーダー向けに最適化されません。",
"accessibilitySupport.on": "エディターは永続的にスクリーン リーダーでの使用向けに最適化されます。単語の折り返しは無効になります。",
"accessibilitySupport": "この UI をスクリーン リーダーに最適化されたモードで実行するかどうかを制御します。",
"accessibilitySupport.auto": "プラットフォーム API を使用して、スクリーン リーダーがいつ接続されたかを検出する",
"accessibilitySupport.off": "スクリーン リーダーが接続されていないと仮定する",
"accessibilitySupport.on": "スクリーン リーダーでの使用に最適化する",
"alternativeDeclarationCommand": "'宣言へ移動' の結果が現在の場所である場合に実行される代替コマンド ID。",
"alternativeDefinitionCommand": "'定義へ移動' の結果が現在の場所である場合に実行される代替コマンド ID。",
"alternativeImplementationCommand": "'実装へ移動' の結果が現在の場所である場合に実行される代替コマンド ID。",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "ユーザーが開始引用符を追加した後、エディター自動的に引用符を閉じるかどうかを制御します。",
"autoIndent": "ユーザーが行を入力、貼り付け、移動、またはインデントするときに、エディターでインデントを自動的に調整するかどうかを制御します。",
"autoSurround": "引用符または角かっこを入力するときに、エディターが選択範囲を自動的に囲むかどうかを制御します。",
"bracketPairColorization.enabled": "角かっこのペアの彩色を有効にするかどうかを制御します。角かっこの強調表示の色をオーバーライドするには、'#workbench.colorCustomizations#' を使用します。",
"bracketPairColorization.enabled": "ブラケットのペアの色付けが有効かどうかを制御します。 {0} を使用して、ブラケットの強調表示の色をオーバーライドします。",
"bracketPairColorization.independentColorPoolPerBracketType": "括弧の各種別が、個別のカラー プールを保持するかどうかを制御します。",
"codeActions": "エディターでコード アクションの電球を有効にします。",
"codeLens": "エディターで CodeLens を表示するかどうかを制御します。",
"codeLensFontFamily": "CodeLens のフォント ファミリを制御します。",
"codeLensFontSize": "CodeLens のフォント サイズをピクセル単位で制御します。'0' に設定すると、'#editor.fontSize#' の 90% が使用されます。",
"codeLensFontSize": "CodeLens のフォント サイズをピクセル単位で制御します。0 に設定すると、`#editor.fontSize#` の 90% が使用されます。",
"colorDecorators": "エディターでインライン カラー デコレーターと色の選択を表示する必要があるかどうかを制御します。",
"colorDecoratorsLimit": "エディターで一度にレンダリングできるカラー デコレーターの最大数を制御します。",
"columnSelection": "マウスとキーでの選択により列の選択を実行できるようにします。",
"comments.ignoreEmptyLines": "行コメントの追加または削除アクションの切り替えで、空の行を無視するかどうかを制御します。",
"comments.insertSpace": "コメント時に空白文字を挿入するかどうかを制御します。",
"copyWithSyntaxHighlighting": "構文ハイライトをクリップボードにコピーするかどうかを制御します。",
"cursorBlinking": "カーソルのアニメーション方式を制御します。",
"cursorSmoothCaretAnimation": "滑らかなキャレットアニメーションを有効にするかどうかを制御します。",
"cursorSmoothCaretAnimation.explicit": "スムーズ キャレット アニメーションは、ユーザーが明示的なジェスチャでカーソルを移動した場合にのみ有効になります。",
"cursorSmoothCaretAnimation.off": "スムーズ キャレット アニメーションが無効になっています。",
"cursorSmoothCaretAnimation.on": "スムーズ キャレット アニメーションは常に有効です。",
"cursorStyle": "カーソルのスタイルを制御します。",
"cursorSurroundingLines": "カーソル前後の表示可能な先頭と末尾の行の最小数を制御します。他の一部のエディターでは 'scrollOff' または `scrollOffset` と呼ばれます。",
"cursorSurroundingLines": "カーソル前後の表示可能な先頭の行 (最小 0) と末尾の行 (最小 1) の最小数を制御します。他の一部のエディターでは 'scrollOff' または 'scrollOffset' と呼ばれます。",
"cursorSurroundingLinesStyle": "'カーソルの周囲の行' を適用するタイミングを制御します。",
"cursorSurroundingLinesStyle.all": "`cursorSurroundingLines` は常に適用されます。",
"cursorSurroundingLinesStyle.default": "`cursorSurroundingLines` は、キーボードまたは API でトリガーされた場合にのみ強制されます。",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "[定義へ移動] マウス ジェスチャーで、常にピーク ウィジェットを開くかどうかを制御します。",
"deprecated": "この設定は非推奨です。代わりに、'editor.suggest.showKeywords' や 'editor.suggest.showSnippets' などの個別の設定を使用してください。",
"dragAndDrop": "ドラッグ アンド ドロップによる選択範囲の移動をエディターが許可するかどうかを制御します。",
"dropIntoEditor.enabled": "(エディターでファイルを開く代わりに) 'shift' を押しながらテキスト エディターにファイルをドラッグ アンド ドロップできるかどうかを制御します。",
"editor.autoClosingBrackets.beforeWhitespace": "カーソルが空白文字の左にあるときだけ、かっこを自動クローズします。",
"editor.autoClosingBrackets.languageDefined": "言語設定を使用して、いつかっこを自動クローズするか決定します。",
"editor.autoClosingDelete.auto": "隣接する終わり引用符または括弧が自動的に挿入された場合にのみ、それらを削除します。",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "縦のブラケット ペアのガイドに加えて、同じく水平のガイドを有効にします。",
"editor.guides.highlightActiveBracketPair": "エディターでアクティブな角かっこのペアを強調表示するかどうかを制御します。",
"editor.guides.highlightActiveIndentation": "エディターでアクティブなインデントのガイドを強調表示するかどうかを制御します。",
"editor.guides.highlightActiveIndentation.always": "角かっこガイドが強調表示されている場合でも、アクティブなインデント ガイドを強調表示します。",
"editor.guides.highlightActiveIndentation.false": "アクティブなインデント ガイドを強調表示しないでください。",
"editor.guides.highlightActiveIndentation.true": "アクティブなインデント ガイドを強調表示します。",
"editor.guides.indentation": "エディターでインデント ガイドを表示するかどうかを制御します。",
"editor.inlayHints.off": "インレイ ヒントが無効になっています",
"editor.inlayHints.offUnlessPressed": "インレイ ヒントは既定では非表示になり、{0} を押したままにすると表示されます",
"editor.inlayHints.on": "インレイ ヒントが有効になっています",
"editor.inlayHints.onUnlessPressed": "インレイ ヒントは既定で表示され、{0} を押したままにすると非表示になります",
"editor.stickyScroll": "スクロール中にエディターの上部に入れ子になった現在のスコープを表示します。",
"editor.stickyScroll.": "表示する追従行の最大数を定義します。",
"editor.suggest.matchOnWordStartOnly": "有効にすると、IntelliSense のフィルター処理では、単語の先頭で最初の文字が一致する必要があります。たとえば、`Console` や `WebContext` の場合は `c`、`description` の場合は _not_ です。無効にすると、IntelliSense はより多くの結果を表示しますが、一致品質で並べ替えられます。",
"editor.suggest.showClasss": "有効にすると、IntelliSense に 'クラス' 候補が表示されます。",
"editor.suggest.showColors": "有効にすると、IntelliSense に `色` 候補が表示されます。",
"editor.suggest.showConstants": "有効にすると、IntelliSense に `定数` 候補が表示されます。",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "有効にすると、IntelliSense に `変数` 候補が表示されます。",
"editorViewAccessibleLabel": "エディターのコンテンツ",
"emptySelectionClipboard": "選択範囲を指定しないでコピーする場合に現在の行をコピーするかどうかを制御します。",
"experimentalWhitespaceRendering": "新しい試験的なメソッドを使用して空白をレンダリングするかどうかを制御します。",
"experimentalWhitespaceRendering.font": "フォント文字に新しいレンダリング方法を使用します。",
"experimentalWhitespaceRendering.off": "安定したレンダリング方法を使用します。",
"experimentalWhitespaceRendering.svg": "SVGS で新しいレンダリング方法を使用します。",
"fastScrollSensitivity": "`Alt` を押すと、スクロール速度が倍増します。",
"find.addExtraSpaceOnTop": "検索ウィジェットがエディターの上に行をさらに追加するかどうかを制御します。true の場合、検索ウィジェットが表示されているときに最初の行を超えてスクロールできます。",
"find.autoFindInSelection": "[選択範囲を検索] を自動的にオンにする条件を制御します。",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "フォントの合字 ('calt' および 'liga' フォントの機能) を有効または無効にします。'font-feature-settings' CSS プロパティを詳細に制御するには、これを文字列に変更します。",
"fontLigaturesGeneral": "フォントの合字やフォントの機能を構成します。合字を有効または無効にするブール値または CSS 'font-feature-settings' プロパティの値の文字列を指定できます。",
"fontSize": "フォント サイズ (ピクセル単位) を制御します。",
"fontVariationSettings": "明示的な 'font-variation-settings' CSS プロパティ。font-weight を font-variation-settings に変換する必要があるだけであれば、代わりにブール値を渡すことができます。",
"fontVariations": "font-weight から font-variation-settings への変換を有効/無効にします。'font-variation-settings' CSS プロパティを細かく制御するために、これを文字列に変更します。",
"fontVariationsGeneral": "フォントのバリエーションを構成します。font-weight から font-variation-settings への変換を有効/無効にするブール値、または CSS 'font-variation-settings' プロパティの値の文字列のいずれかです。",
"fontWeight": "フォントの太さを制御します。\"標準\" および \"太字\" のキーワードまたは 1 ～ 1000 の数字を受け入れます。",
"fontWeightErrorMessage": "使用できるのは \"標準\" および \"太字\" のキーワードまたは 1 ～ 1000 の数字のみです。",
"formatOnPaste": "貼り付けた内容がエディターにより自動的にフォーマットされるかどうかを制御します。フォーマッタを使用可能にする必要があります。また、フォーマッタがドキュメント内の範囲をフォーマットできなければなりません。",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "ホバーを表示するかどうかを制御します。",
"hover.sticky": "ホバーにマウスを移動したときに、ホバーを表示し続けるかどうかを制御します。",
"inlayHints.enable": "エディターでインレー ヒントを有効にします。",
"inlayHints.fontFamily": "エディターでインレー ヒントのフォント ファミリを制御します。空に設定すると、`#editor.fontFamily#` が使用されます。",
"inlayHints.fontSize": "エディター内のインレイ ヒントのフォント サイズを制御します。既定値の 90% の `#editor.fontSize#` は、構成された値が `5` より小さいか、エディター フォント サイズより大きい場合に使用されます。",
"inlayHints.fontFamily": "エディターで解説ヒントのフォント ファミリを制御します。空に設定すると、 {0} が使用されます。",
"inlayHints.fontSize": "エディターでの解説ヒントのフォント サイズを制御します。既定では、{0} は、構成された値が {1} より小さいか、エディターのフォント サイズより大きい場合に使用されます。",
"inlayHints.padding": "エディターでのインレイ ヒントに関するパディングを有効にします。",
"inline": "クイック候補がゴースト テキストとして表示される",
"inlineSuggest.enabled": "エディターにインライン候補を自動的に表示するかどうかを制御します。",
"inlineSuggest.showToolbar": "インライン候補ツール バーを表示するタイミングを制御します。",
"inlineSuggest.showToolbar.always": "インライン候補が表示されるたびに、インライン候補ツール バーを表示します。",
"inlineSuggest.showToolbar.onHover": "インライン候補にカーソルを合わせるたびに、インライン候補ツール バーを表示します。",
"letterSpacing": "文字間隔 (ピクセル単位) を制御します。",
"lineHeight": "行の高さを制御します。\r\n - 0 を使用してフォント サイズから行の高さを自動的に計算します。\r\n - 0 から 8 までの値は、フォント サイズの乗数として使用されます。\r\n - 8 以上の値は有効値として使用されます。",
"lineNumbers": "行番号の表示を制御します。",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "リンクされた編集がエディターで有効にされるかどうかを制御します。言語によっては、編集中に HTML タグなどの関連する記号が更新されます。",
"links": "エディターがリンクを検出してクリック可能な状態にするかどうかを制御します。",
"matchBrackets": "対応するかっこを強調表示します。",
"minimap.autohide": "ミニマップを自動的に非表示するかどうかを制御します。",
"minimap.enabled": "ミニマップを表示するかどうかを制御します。",
"minimap.maxColumn": "表示するミニマップの最大幅を特定の列数に制限します。",
"minimap.renderCharacters": "行にカラー ブロックではなく実際の文字を表示します。",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "ミニマップのサイズは、エディターのコンテンツと同じです (スクロールする場合があります)。",
"mouseWheelScrollSensitivity": "マウス ホイール スクロール イベントの `deltaX` と `deltaY` で使用される乗数。",
"mouseWheelZoom": "`Ctrl` キーを押しながらマウス ホイールを使用してエディターのフォントをズームします。",
"multiCursorLimit": "アクティブなエディターに一度に配置できるカーソルの最大数を制御します。",
"multiCursorMergeOverlapping": "複数のカーソルが重なっているときは、マージします。",
"multiCursorModifier": "マウスを使用して複数のカーソルを追加するときに使用する修飾子です。「定義に移動」や「リンクを開く」のマウス ジェスチャーは、マルチカーソルの修飾子と競合しないように適用されます。[詳細](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier)。",
"multiCursorModifier": "マウスを使用して複数のカーソルを追加するために使用する修飾子。[定義に移動] および [リンクを開く] マウス ジェスチャは、[multicursor 修飾子](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier) と競合しないように調整されます。",
"multiCursorModifier.alt": "Windows および Linux 上の `Alt` キーと macOS 上の `Option` キーに割り当てます。",
"multiCursorModifier.ctrlCmd": "Windows および Linux 上の `Control` キーと macOS 上の `Command` キーに割り当てます。",
"multiCursorPaste": "貼り付けたテキストの行数がカーソル数と一致する場合の貼り付けを制御します。",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "ピーク ウィジェットのインライン エディターまたはツリーをフォーカスするかどうかを制御します。",
"peekWidgetDefaultFocus.editor": "ピークを開くときにエディターにフォーカスする",
"peekWidgetDefaultFocus.tree": "ピークを開くときにツリーにフォーカスする",
"quickSuggestions": "入力中に候補を自動的に表示するかどうかを制御します。",
"quickSuggestions": "入力中に候補を自動的に表示するかどうかを制御します。これは、コメント、文字列、その他コードの入力用に設定できます。クイック提案は、ゴースト テキストとして表示するか、提案ウィジェットで表示するように構成できます。また、'{0}' に注意してください。これは、提案が特殊文字によってトリガーされるかどうかを制御する設定です。",
"quickSuggestions.comments": "コメント内でクイック候補を有効にします。",
"quickSuggestions.other": "文字列およびコメント外でクイック候補を有効にします。",
"quickSuggestions.strings": "文字列内でクイック候補を有効にします。",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "とじしろのの折りたたみコントロールを表示するタイミングを制御します。",
"showFoldingControls.always": "常に折りたたみコントロールを表示します。",
"showFoldingControls.mouseover": "マウスがとじしろの上にあるときにのみ、折りたたみコントロールを表示します。",
"showFoldingControls.never": "折りたたみコントロールを表示せず、余白のサイズを小さくします。",
"showUnused": "使用されていないコードのフェードアウトを制御します。",
"smoothScrolling": "アニメーションでエディターをスクロールするかどうかを制御します。",
"snippetSuggestions": "他の修正候補と一緒にスニペットを表示するかどうか、およびその並び替えの方法を制御します。",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "インデントにスペースを使用するときは、タブ文字の選択動作をエミュレートします。選択範囲はタブ位置に留まります。",
"suggest.filterGraceful": "候補のフィルター処理と並び替えでささいな入力ミスを考慮するかどうかを制御します。",
"suggest.insertMode": "入力候補を受け入れるときに単語を上書きするかどうかを制御します。これは、この機能の利用を選択する拡張機能に依存することにご注意ください。",
"suggest.insertMode.always": "IntelliSense を自動でトリガーする場合に、常に候補を選択します。",
"suggest.insertMode.insert": "カーソルの右のテキストを上書きせずに候補を挿入します。",
"suggest.insertMode.never": "IntelliSense を自動でトリガーする場合に、候補を選択しません。",
"suggest.insertMode.replace": "候補を挿入し、カーソルの右のテキストを上書きします。",
"suggest.insertMode.whenQuickSuggestion": "入力時に IntelliSense をトリガーする場合にのみ、候補を選択します。",
"suggest.insertMode.whenTriggerCharacter": "トリガー文字から IntelliSense をトリガーする場合にのみ、候補を選択します。",
"suggest.localityBonus": "並べ替えがカーソル付近に表示される単語を優先するかどうかを制御します。",
"suggest.maxVisibleSuggestions.dep": "この設定は非推奨です。候補ウィジェットのサイズ変更ができるようになりました。",
"suggest.preview": "提案の結果をエディターでプレビューするかどうかを制御します。",
"suggest.selectionMode": "ウィジェットを表示する際に候補を選択するかどうかを制御します。こちらは自動的にトリガーされる候補 ('#editor.quickSuggestions#' と '#editor.suggestOnTriggerCharacters#') にのみ適用され、('Ctrl+Space' などを通じて) 明示的に呼び出される際には常に候補が選択されることにご注意ください。",
"suggest.shareSuggestSelections": "保存された候補セクションを複数のワークプレースとウィンドウで共有するかどうかを制御します (`#editor.suggestSelection#` が必要)。",
"suggest.showIcons": "提案のアイコンを表示するか、非表示にするかを制御します。",
"suggest.showInlineDetails": "候補の詳細をラベル付きのインラインで表示するか、詳細ウィジェットにのみ表示するかを制御します",
"suggest.showInlineDetails": "候補の詳細をラベル付きのインラインで表示するか、詳細ウィジェットにのみ表示するかを制御します。",
"suggest.showStatusBar": "候補ウィジェットの下部にあるステータス バーの表示を制御します。",
"suggest.snippetsPreventQuickSuggestions": "アクティブ スニペットがクイック候補を防止するかどうかを制御します。",
"suggestFontSize": "候補ウィジェットのフォント サイズ。`0` に設定すると、`#editor.fontSize#` の値が使用されます。",
"suggestLineHeight": "候補ウィジェットの行の高さ。`0` に設定すると、`#editor.lineHeight#` の値が使用されます。最小値は 8 です。",
"suggestFontSize": "候補ウィジェットのフォント サイズ。{0} に設定すると、値 {1} が使用されます。",
"suggestLineHeight": "候補ウィジェットの行の高さ。{0} に設定すると、{1} の値が使用されます。最小値は 8 です。",
"suggestOnTriggerCharacters": "トリガー文字の入力時に候補が自動的に表示されるようにするかどうかを制御します。",
"suggestSelection": "候補リストを表示するときに候補を事前に選択する方法を制御します。",
"suggestSelection.first": "常に最初の候補を選択します。",
@ -410,19 +465,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "タブ補完を無効にします。",
"tabCompletion.on": "タブ補完は、tab キーを押したときに最適な候補を挿入します。",
"tabCompletion.onlySnippets": "プレフィックスが一致する場合に、タブでスニペットを補完します。'quickSuggestions' が無効な場合に最適です。",
"unfoldOnClickAfterEndOfLine": "折りたたまれた線の後の空のコンテンツをクリックすると線が展開されるかどうかを制御します。",
"unicodeHighlight.allowedCharacters": "強調表示されていない許可される文字を定義します。",
"unicodeHighlight.allowedLocales": "許可されているロケールで一般的な Unicode 文字が強調表示されていません。",
"tabFocusMode": "エディターがタブを受け取るか、ワークベンチに委ねてナビゲーションするかを制御します。",
"unfoldOnClickAfterEndOfLine": "折りたたまれた行の後の空のコンテンツをクリックすると行が展開されるかどうかを制御します。",
"unicodeHighlight.allowedCharacters": "強調表示せず許可される文字を定義します。",
"unicodeHighlight.allowedLocales": "許可されているロケールで一般的な Unicode 文字は強調表示されません。",
"unicodeHighlight.ambiguousCharacters": "現在のユーザー ロケールで一般的な文字を除き、基本的な ASCII 文字と混同される可能性のある文字を強調表示するかどうかを制御します。",
"unicodeHighlight.includeComments": "コメント内の文字を Unicode 強調表示の対象にするかどうかを制御します。",
"unicodeHighlight.includeStrings": "文字列内の文字を Unicode 強調表示の対象にするかどうかを制御します。",
"unicodeHighlight.invisibleCharacters": "スペースを予約するだけの文字または幅がまったくない文字を強調表示するかどうかを制御します。",
"unicodeHighlight.nonBasicASCII": "基本以外のすべての ASCII 文字を強調表示するかどうかを制御します。U+0020 から U+007Eの間の文字、Tab、改行コード、行頭復帰のみが基本 ASCII と見なされます。",
"unicodeHighlight.invisibleCharacters": "空白を占めるだけの文字や幅がまったくない文字を強調表示するかどうかを制御します。",
"unicodeHighlight.nonBasicASCII": "基本 ASCII 以外のすべての文字を強調表示するかどうかを制御します。U+0020 から U+007E の間の文字、タブ、改行 (LF)、行頭復帰のみが基本 ASCII と見なされます。",
"unusualLineTerminators": "問題を起こす可能性がある、普通ではない行終端記号は削除してください。",
"unusualLineTerminators.auto": "通常とは異なる行の終端文字は自動的に削除される。",
"unusualLineTerminators.off": "通常とは異なる行の終端文字は無視される。",
"unusualLineTerminators.prompt": "通常とは異なる行の終端文字の削除プロンプトが表示される。",
"useTabStops": "空白の挿入や削除はタブ位置に従って行われます。",
"wordBreak": "中国語/日本語/韓国語 (CJK) テキストに使用される単語区切り規則を制御します。",
"wordBreak.keepAll": "中国語/日本語/韓国語 (CJK) のテキストには単語区切りを使用しないでください。CJK 以外のテキストの動作は、通常の場合と同じです。",
"wordBreak.normal": "既定の改行ルールを使用します。",
"wordSeparators": "単語に関連したナビゲーションまたは操作を実行するときに、単語の区切り文字として使用される文字。",
"wordWrap": "行の折り返し方法を制御します。",
"wordWrap.bounded": "ビューポートと `#editor.wordWrapColumn#` の最小値で行を折り返します。",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "折り返し行は、親 +1 のインデントになります。",
"wrappingIndent.none": "インデントしません。 折り返し行は列 1 から始まります。",
"wrappingIndent.same": "折り返し行は、親と同じインデントになります。",
"wrappingStrategy": "折り返しポイントを計算するアルゴリズムを制御します。",
"wrappingStrategy": "折り返しポイントを計算するアルゴリズムを制御します。アクセシビリティ モードでは、最高のエクスペリエンスを実現するために詳細設定が使用されることにご注意ください。",
"wrappingStrategy.advanced": "折り返しポイントの計算をブラウザーにデリゲートします。これは、大きなファイルのフリーズを引き起こす可能性があるものの、すべてのケースで正しく動作する低速なアルゴリズムです。",
"wrappingStrategy.simple": "すべての文字の幅が同じであると仮定します。これは、モノスペース フォントや、グリフの幅が等しい特定のスクリプト (ラテン文字など) で正しく動作する高速アルゴリズムです。"
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "非アクティブな角かっこのペア ガイドの背景色 (6)。角かっこのペア ガイドを有効にする必要があります。",
"editorCodeLensForeground": "CodeLens エディターの前景色。",
"editorCursorBackground": "選択された文字列の背景色です。選択された文字列の背景色をカスタマイズ出来ます。",
"editorDimmedLineNumber": "editor.renderFinalNewline が dimmed に設定されている場合のエディターの最終行の色。",
"editorGhostTextBackground": "エディターのゴースト テキストの背景色。",
"editorGhostTextBorder": "エディター内の透かし文字の境界線の色です。",
"editorGhostTextForeground": "エディターの透かし文字の前景色です。",
"editorGutter": "エディターの余白の背景色。余白にはグリフ マージンと行番号が含まれます。",
"editorIndentGuides": "エディター インデント ガイドの色。",
"editorLineNumbers": "エディターの行番号の色。",
"editorOverviewRulerBackground": "エディターの概要ルーラーの背景色です。ミニマップが有効で、エディターの右側に配置されている場合にのみ使用します。",
"editorOverviewRulerBackground": "エディターの概要ルーラーの背景色。",
"editorOverviewRulerBorder": "概要ルーラーの境界色。",
"editorRuler": "エディター ルーラーの色。",
"editorUnicodeHighlight.background": "Unicode 文字を強調表示するために使用される背景色。",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "現在のエディターで Tab キーを押すと、次のフォーカス可能な要素にフォーカスを移動します。コマンド {0} は、キー バインドでは現在トリガーできません。",
"toggleHighContrast": "ハイ コントラスト テーマの切り替え"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} 文字",
"showMore": "表示数を増やす ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "アンカーが {0}:{1} に設定されました",
"cancelSelectionAnchor": "選択アンカーの取り消し",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "形式を指定してコピー",
"miCopy": "コピー(&&C)",
"miCut": "切り取り(&&T)",
"miPaste": "貼り付け(&&P)"
"miPaste": "貼り付け(&&P)",
"share": "共有"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "コード アクションの適用中に不明なエラーが発生しました"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "コード アクションの適用中に不明なエラーが発生しました",
"args.schema.apply": "返されたアクションが適用されるタイミングを制御します。",
"args.schema.apply.first": "最初に返されたコード アクションを常に適用します。",
"args.schema.apply.ifSingle": "最初に返されたコード アクション以外に返されたコード アクションがない場合は、そのアクションを適用します。",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "インポートを整理",
"quickfix.trigger.label": "クイック フィックス...",
"refactor.label": "リファクター...",
"refactor.preview.label": "プレビューを使用したリファクター...",
"source.label": "ソース アクション..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "コード アクション メニューでのグループ ヘッダーの表示の有効/無効を切り替えます。"
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "再書き込みします...",
"codeAction.widget.id.extract": "抽出します...",
"codeAction.widget.id.inline": "インライン...",
"codeAction.widget.id.more": "その他の操作...",
"codeAction.widget.id.move": "移動...",
"codeAction.widget.id.quickfix": "クイック フィックス...",
"codeAction.widget.id.source": "ソース アクション...",
"codeAction.widget.id.surround": "ブロックの挿入..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "無効なものを非表示",
"showMoreActions": "無効を表示"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "コード アクションの表示",
"codeActionWithKb": "コード アクションの表示 ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "行コメントの切り替え(&&T)"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "エディターのコンテキスト メニューの表示"
"action.showContextMenu.label": "エディターのコンテキスト メニューの表示",
"context.minimap.minimap": "ミニマップ",
"context.minimap.renderCharacters": "レンダリング文字",
"context.minimap.size": "垂直方向のサイズ",
"context.minimap.size.fill": "塗りつぶし",
"context.minimap.size.fit": "サイズに合わせて調整",
"context.minimap.size.proportional": "均等",
"context.minimap.slider": "スライダー",
"context.minimap.slider.always": "常に",
"context.minimap.slider.mouseover": "マウス オーバー"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "貼り付け時に拡張機能からの編集の実行を有効化/無効化してください。"
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "貼り付けハンドラーを実行しています..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "カーソルのやり直し",
"cursor.undo": "カーソルを元に戻す"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "ドロップ ハンドラーを実行しています..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "エディターで取り消し可能な操作 ('参照をここに表示' など) を実行するかどうか"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "\"数式ケース\" フラグをオーバーライドします。\r\nフラグは今後保存されません。\r\n0: 何もしない\r\n1: True\r\n2: False",
"actions.find.preserveCaseOverride": "\"ケースの保持\" フラグをオーバーライドします。\r\nフラグは今後保存されません。\r\n0: 何もしない\r\n1: True\r\n2: False",
"actions.find.wholeWordOverride": "\"単語単位で検索する\" フラグをオーバーライドします。\r\nフラグは今後保存されません。\r\n0: 何もしない\r\n1: True\r\n2: False",
"findMatchAction.goToMatch": "[一致] に移動...",
"findMatchAction.inputPlaceHolder": "特定の一致に移動する数値を入力します (1 から {0})",
"findMatchAction.inputValidationMessage": "1 ~ {0} の数を入力してください。",
"findNextMatchAction": "次を検索",
"findPreviousMatchAction": "前を検索",
"miFind": "検索(&&F)",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "最初の {0} 件の結果だけが強調表示されますが、すべての検索操作はテキスト全体で機能します。"
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "エディターの余白にある折りたたみコントロールの色。",
"createManualFoldRange.label": "選択範囲から折りたたみ範囲を作成する",
"foldAction.label": "折りたたみ",
"foldAllAction.label": "すべて折りたたみ",
"foldAllBlockComments.label": "すべてのブロック コメントの折りたたみ",
"foldAllExcept.label": "選択されたものを除くすべての領域を折りたたむ",
"foldAllMarkerRegions.label": "すべての領域を折りたたむ",
"foldBackgroundBackground": "折り曲げる範囲の背景色。基の装飾を隠さないように、色は不透明であってはなりません。",
"foldLevelAction.label": "レベル {0} で折りたたむ",
"foldRecursivelyAction.label": "再帰的に折りたたむ",
"gotoNextFold.label": "次のフォールディング範囲に移動する",
"gotoParentFold.label": "親フォールドに移動する",
"gotoPreviousFold.label": "前のフォールディング範囲に移動する",
"maximum fold ranges": "折りたたみ可能な領域の数は、最大 {0} 個に制限されます。より多くを有効にするには、構成オプション ['Folding Maximum Regions'](command:workbench.action.openSettings?[\"editor.foldingMaximumRegions\"]) の値を大きくします。",
"removeManualFoldingRanges.label": "手動折りたたみ範囲を削除する",
"toggleFoldAction.label": "折りたたみの切り替え",
"unFoldRecursivelyAction.label": "再帰的に展開する",
"unfoldAction.label": "展開",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "すべての領域を展開"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "エディターの余白にある折りたたみコントロールの色。",
"foldBackgroundBackground": "折り曲げる範囲の背景色。基の装飾を隠さないように、色は不透明であってはなりません。",
"foldingCollapsedIcon": "エディターのグリフ余白内の折りたたまれた範囲のアイコン。",
"foldingExpandedIcon": "エディターのグリフ余白内の展開された範囲のアイコン。"
"foldingExpandedIcon": "エディターのグリフ余白内の展開された範囲のアイコン。",
"foldingManualCollapedIcon": "エディターのグリフ余白内の折りたたまれた範囲のアイコン。",
"foldingManualExpandedIcon": "エディターのグリフ余白内で手動で展開された範囲のアイコン。"
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "エディターのフォントを拡大",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "読み込んでいます...",
"stopped rendering": "パフォーマンス上の理由から、長い行のためにレンダリングが一時停止されました。これは `editor.stopRenderingLineAfter` で設定できます。",
"too many characters": "パフォーマンス上の理由からトークン化はスキップされます。その長い行の長さは `editor.maxTokenizationLineLength` で構成できます。"
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "問題の表示"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "タブの表示サイズの変更",
"configuredTabSize": "構成されたタブのサイズ",
"currentTabSize": "現在のタブ サイズ",
"defaultTabSize": "既定のタブ サイズ",
"detectIndentation": "内容からインデントを検出",
"editor.reindentlines": "行の再インデント",
"editor.reindentselectedlines": "選択行を再インデント",
@ -864,7 +977,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/inlayHints/browser/inlayHintsHover": {
"hint.cmd": "コマンドの実行",
"hint.dbl": "ダブル クリックして挿入する",
"hint.dbl": "ダブルクリックして挿入する",
"hint.def": "定義に移動 ({0})",
"hint.defAndCommand": "[定義] ({0}) に移動し、右クリックして詳細を表示します",
"links.navigate.kb.alt": "alt キーを押しながらクリック",
@ -873,22 +986,44 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd キーを押しながらクリック"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "承諾する",
"acceptWord": "ワードを承諾する",
"action.inlineSuggest.accept": "インライン候補を承諾する",
"action.inlineSuggest.acceptNextWord": "インライン提案の次の単語を承諾する",
"action.inlineSuggest.alwaysShowToolbar": "常にツール バーを表示する",
"action.inlineSuggest.hide": "インライン候補を非表示にする",
"action.inlineSuggest.showNext": "次のインライン候補を表示する",
"action.inlineSuggest.showPrevious": "前のインライン候補を表示する",
"action.inlineSuggest.trigger": "インライン候補をトリガーする",
"action.inlineSuggest.undo": "ワードの承認を元に戻す",
"alwaysShowInlineSuggestionToolbar": "インライン提案ツール バーを常に表示するかどうか",
"canUndoInlineSuggestion": "元に戻す場合にインライン候補を元に戻すかどうか",
"inlineSuggestionHasIndentation": "インライン候補がスペースで始まるかどうか",
"inlineSuggestionHasIndentationLessThanTabSize": "インライン候補が、タブで挿入されるものよりも小さいスペースで始まるかどうか",
"inlineSuggestionVisible": "インライン候補を表示するかどうか"
"inlineSuggestionVisible": "インライン候補を表示するかどうか",
"undoAcceptWord": "ワードの承諾を元に戻す"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "おすすめ:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "次へ",
"parameterHintsNextIcon": "次のパラメーター ヒントを表示するためのアイコン。",
"parameterHintsPreviousIcon": "前のパラメーター ヒントを表示するためのアイコン。",
"previous": "前へ"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "次の値に置換",
"InPlaceReplaceAction.previous.label": "前の値に置換"
},
"vs/editor/contrib/lineSelection/browser/lineSelection": {
"expandLineSelection": "線の選択を展開する"
"expandLineSelection": "行全体を選択する"
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "選択範囲の複製",
"editor.transformToCamelcase": "キャメル ケースに変換する",
"editor.transformToKebabcase": "Kebab ケースへの変換",
"editor.transformToLowercase": "小文字に変換",
"editor.transformToSnakecase": "スネーク ケースに変換する",
"editor.transformToTitlecase": "先頭文字を大文字に変換する",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "コマンド {0} の実行"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "読み取り専用のエディターは編集できません",
"messageVisible": "エディターに現在インライン メッセージが表示されているかどうか"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "最後に選んだ項目を前の一致項目に移動する",
"mutlicursor.addCursorsToBottom": "カーソルを下に挿入",
"mutlicursor.addCursorsToTop": "カーソルを上に挿入",
"mutlicursor.focusNextCursor": "次のカーソルにフォーカス",
"mutlicursor.focusNextCursor.description": "次のカーソルにフォーカスを合わせる",
"mutlicursor.focusPreviousCursor": "前のカーソルにフォーカスする",
"mutlicursor.focusPreviousCursor.description": "前のカーソルにフォーカスを合わせる",
"mutlicursor.insertAbove": "カーソルを上に挿入",
"mutlicursor.insertAtEndOfEachLineSelected": "カーソルを行末に挿入",
"mutlicursor.insertBelow": "カーソルを下に挿入",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "ピーク ビュー エディターの余白の背景色。",
"peekViewEditorMatchHighlight": "ピーク ビュー エディターの一致した強調表示色。",
"peekViewEditorMatchHighlightBorder": "ピーク ビュー エディターの一致した強調境界色。",
"peekViewEditorStickScrollBackground": "ピーク ビュー エディターでの固定スクロールの背景色。",
"peekViewResultsBackground": "ピーク ビュー結果リストの背景色。",
"peekViewResultsFileForeground": "ピーク ビュー結果リストのファイル ノードの前景色。",
"peekViewResultsMatchForeground": "ピーク ビュー結果リストのライン ノードの前景色。",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "型パラメーター ({0})",
"variable": "変数 ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "読み取り専用のエディターは編集できません",
"editor.simple.readonly": "読み取り専用の入力では編集できません"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "'{0}' から '{1}' への名前変更が正常に完了しました。概要: {2}",
"enablePreview": "名前を変更する前に変更をプレビューする機能を有効または無効にする",
"label": "'{0}' の名前の変更中",
"label": "名前を '{0}' から '{1}' に変更しています",
"no result": "結果がありません。",
"quotableLabel": "{0} の名前を変更しています",
"quotableLabel": "{0} の名前を {1} に変更しています",
"rename.failed": "名前の変更によって編集の計算に失敗しました",
"rename.failedApply": "名前の変更で編集を適用できませんでした",
"rename.label": "シンボルの名前変更",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "スニペット モードのときに、次のタブ位置があるかどうか",
"hasPrevTabstop": "スニペット モードのときに、前のタブ位置があるかどうか",
"inSnippetMode": "現在のエディターがスニペット モードであるかどうか"
"inSnippetMode": "現在のエディターがスニペット モードであるかどうか",
"next": "次のプレースホルダーに移動..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "4 月",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "水曜日",
"WednesdayShort": "水"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "固定スクロール(&&)",
"mitoggleStickyScroll": "固定スクロールの切り替え(&&T)",
"stickyScroll": "固定スクロール",
"toggleStickyScroll": "固定スクロールの切り替え"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Enter キーを押したときに候補を挿入するかどうか",
"suggestWidgetDetailsVisible": "候補の詳細が表示されるかどうか",
"suggestWidgetHasSelection": "候補がフォーカスされているかどうか",
"suggestWidgetMultipleSuggestions": "選択する複数の候補があるかどうか",
"suggestionCanResolve": "現在の候補からの詳細の解決をサポートするかどうか",
"suggestionHasInsertAndReplaceRange": "現在の候補に挿入と置換の動作があるかどうか",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "提案ウィジェットの詳細情報のアイコン。"
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "配列記号の前景色。これらの記号は、アウトライン、階層リンク、および候補のウィジェットに表示されます。",
@ -1185,53 +1336,107 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter": {
"action.unicodeHighlight.disableHighlightingInComments": "コメントの文字の強調表示を無効にする",
"action.unicodeHighlight.disableHighlightingInStrings": "文字列の文字の強調表示を無効にする",
"action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters": "あいまいな文字の強調表示を無効にする",
"action.unicodeHighlight.disableHighlightingOfInvisibleCharacters": "非表示の文字の強調表示を無効にする",
"action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters": "基本以外の ASCII 文字の強調表示を無効にする",
"action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters": "まぎらわしい文字の強調表示を無効にする",
"action.unicodeHighlight.disableHighlightingOfInvisibleCharacters": "不可視の文字の強調表示を無効にする",
"action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters": "基本 ASCII 以外の文字の強調表示を無効にする",
"action.unicodeHighlight.showExcludeOptions": "除外オプションの表示",
"unicodeHighlight.adjustSettings": "設定の調整",
"unicodeHighlight.allowCommonCharactersInLanguage": "言語 \"{0}\" でより一般的な Unicode 文字を許可します。",
"unicodeHighlight.characterIsAmbiguous": "文字 {0}は、ソース コードでより一般的な文字{1}と混同される可能性があります。",
"unicodeHighlight.characterIsInvisible": "文字 {0}は非表示です。",
"unicodeHighlight.characterIsNonBasicAscii": "文字 {0} は基本的な ASCII 文字ではありません。",
"unicodeHighlight.characterIsNonBasicAscii": "文字 {0} は基本 ASCII 文字ではありません。",
"unicodeHighlight.configureUnicodeHighlightOptions": "Unicode の強調表示オプションを構成する",
"unicodeHighlight.disableHighlightingInComments.shortLabel": "コメントの強調表示を無効にする",
"unicodeHighlight.disableHighlightingInStrings.shortLabel": "文字列の強調表示を無効にする",
"unicodeHighlight.disableHighlightingOfAmbiguousCharacters.shortLabel": "多義性文字の強調表示を無効にする",
"unicodeHighlight.disableHighlightingOfInvisibleCharacters.shortLabel": "非表示文字の強調表示を無効にする",
"unicodeHighlight.disableHighlightingOfAmbiguousCharacters.shortLabel": "まぎらわしい文字の強調表示を無効にする",
"unicodeHighlight.disableHighlightingOfInvisibleCharacters.shortLabel": "不可視文字の強調表示を無効にする",
"unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters.shortLabel": "非 ASCII 文字の強調表示を無効にする",
"unicodeHighlight.excludeCharFromBeingHighlighted": "強調表示から {0} を除外します",
"unicodeHighlight.excludeInvisibleCharFromBeingHighlighted": "{0} (非表示の文字) を強調表示から除外する",
"unicodeHighlighting.thisDocumentHasManyAmbiguousUnicodeCharacters": "このドキュメントには多義性を持つ Unicode 文字が多数含まれています",
"unicodeHighlighting.thisDocumentHasManyInvisibleUnicodeCharacters": "このドキュメントには非表示の Unicode 文字が多数含まれています",
"unicodeHighlighting.thisDocumentHasManyNonBasicAsciiUnicodeCharacters": "このドキュメントには、数多くの非基本 ASCII Unicode 文字が含まれています",
"unicodeHighlight.excludeInvisibleCharFromBeingHighlighted": "{0} (不可視の文字) を強調表示から除外する",
"unicodeHighlighting.thisDocumentHasManyAmbiguousUnicodeCharacters": "このドキュメントにはまぎらわしい Unicode 文字が多数含まれています",
"unicodeHighlighting.thisDocumentHasManyInvisibleUnicodeCharacters": "このドキュメントには不可視の Unicode 文字が多数含まれています",
"unicodeHighlighting.thisDocumentHasManyNonBasicAsciiUnicodeCharacters": "このドキュメントには、基本 ASCII 外の Unicode 文字が多数含まれています",
"warningIcon": "拡張機能のエディターで警告メッセージと共に表示されるアイコン。"
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "このファイル '{0}' には、行区切り文字 (LS) や段落区切り記号 (PS) などの特殊な行の終端文字が 1 つ以上含まれています。\r\n\r\nそれらをファイルから削除することをお勧めします。これは 'editor.unusualLineTerminators' を使用して構成できます。",
"unusualLineTerminators.fix": "特殊な行の終端記号を削除する",
"unusualLineTerminators.fix": "特殊な行の終端記号を削除する(&&R)",
"unusualLineTerminators.ignore": "無視する",
"unusualLineTerminators.message": "普通ではない行終端記号が検出されました",
"unusualLineTerminators.title": "普通ではない行終端記号"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "シンボルによって強調表示される概要ルーラーのマーカーの色。マーカーの色は、基になる装飾を隠さないように不透明以外にします。",
"overviewRulerWordHighlightStrongForeground": "書き込みアクセス シンボルを強調表示する概要ルーラーのマーカー色。下にある装飾を隠さないために、色は不透過であってはなりません。",
"overviewRulerWordHighlightTextForeground": "記号のテキスト出現の概要ルール マーカーの色。基になる装飾が非表示ならないように、この色を不透明にすることはできません。",
"wordHighlight": "変数の読み取りなど、読み取りアクセス中のシンボルの背景色。下にある装飾を隠さないために、色は不透過であってはなりません。",
"wordHighlight.next.label": "次のシンボル ハイライトに移動",
"wordHighlight.previous.label": "前のシンボル ハイライトに移動",
"wordHighlight.trigger.label": "シンボル ハイライトをトリガー",
"wordHighlightBorder": "変数の読み取りなど読み取りアクセス中のシンボルの境界線の色。",
"wordHighlightStrong": "変数への書き込みなど、書き込みアクセス中のシンボル背景色。下にある装飾を隠さないために、色は不透過であってはなりません。",
"wordHighlightStrongBorder": "変数への書き込みなど書き込みアクセス中のシンボルの境界線の色。"
"wordHighlightStrongBorder": "変数への書き込みなど書き込みアクセス中のシンボルの境界線の色。",
"wordHighlightText": "記号のテキスト出現の背景色。基になる装飾が非表示ならないように、この色を不透明にすることはできません。",
"wordHighlightTextBorder": "記号のテキスト出現箇所の境界線の色。"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "次のシンボル ハイライトに移動",
"wordHighlight.previous.label": "前のシンボル ハイライトに移動",
"wordHighlight.trigger.label": "シンボル ハイライトをトリガー"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "単語の削除"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "開発者",
"help": "ヘルプ",
"preferences": "基本設定",
"test": "テスト",
"view": "表示"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "非表示",
"resetThisMenu": "メニューのリセット"
},
"vs/platform/actions/common/menuService": {
"hide.label": "'{0}' の非表示"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "アクション ウィジェット",
"customQuickFixWidget.labels": "{0}、無効になった理由: {1}",
"label": "適用するには {0}",
"label-preview": "{0} で適用する、{1} でプレビューする"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "選択した操作を承諾",
"codeActionMenuVisible": "アクション ウィジェットの一覧が表示されるかどうか",
"hideCodeActionWidget.title": "アクション ウィジェットを非表示にする",
"previewSelected.title": "選択したアクションのプレビュー",
"selectNextCodeAction.title": "次のアクションを選択",
"selectPrevCodeAction.title": "前のアクションを選択"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "差分行が削除されました",
"audioCues.diffLineInserted": "差分行が挿入されました",
"audioCues.diffLineModified": "変更された差分行",
"audioCues.lineHasBreakpoint.name": "行のブレークポイント",
"audioCues.lineHasError.name": "行のエラー",
"audioCues.lineHasFoldedArea.name": "行の折りたたまれた面",
"audioCues.lineHasInlineSuggestion.name": "行のインライン候補",
"audioCues.lineHasWarning.name": "行の警告",
"audioCues.noInlayHints": "行にインレイ ヒントがありません",
"audioCues.notebookCellCompleted": "ノートブック セルが完了しました",
"audioCues.notebookCellFailed": "ノートブック セルが失敗しました",
"audioCues.onDebugBreak.name": "ブレークポイントでデバッガーが停止しました",
"audioCues.taskCompleted": "タスクが完了しました",
"audioCues.taskFailed": "タスクが失敗しました",
"audioCues.terminalBell": "ターミナル ベル",
"audioCues.terminalCommandFailed": "ターミナル コマンドが失敗しました",
"audioCues.terminalQuickFix.name": "ターミナル クイック修正"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "'{0}' を登録できません。関連付けられたポリシー {1} は既に {2} に登録されています。",
"config.property.duplicate": "'{0}' を登録できません。このプロパティは既に登録されています。",
"config.property.empty": "空のプロパティは登録できません",
"config.property.languageDefault": "'{0}' を登録できません。これは、言語固有のエディター設定を記述するプロパティ パターン '\\\\[.*\\\\]$' に一致しています。'configurationDefaults' コントリビューションを使用してください。",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "オペレーティング システムが Linux であるかどうか",
"isMac": "オペレーティング システムが macOS であるかどうか",
"isMacNative": "オペレーティング システムが非ブラウザー プラットフォーム上の macOS であるかどうか",
"isMobile": "プラットフォームがモバイル Web ブラウザーであるかどうか",
"isWeb": "プラットフォームが Web ブラウザーであるかどうか",
"isWindows": "オペレーティング システムが Windows であるかどうか"
"isWindows": "オペレーティング システムが Windows であるかどうか",
"productQualityType": "VS Code の品質の種類"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "キャンセル",
"moreFile": "...1 つの追加ファイルが表示されていません",
"moreFiles": "...{0} 個の追加ファイルが表示されていません"
"moreFiles": "...{0} 個の追加ファイルが表示されていません",
"okButton": "OK(&&O)",
"yesButton": "はい(&&Y)"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "ファイルが大きすぎて無題のエディターとして開けません。まずファイル エクスプローラーにアップロードしてから、もう一度お試しください。"
},
"vs/platform/files/common/files": {
"sizeB": "{0}B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "`Alt` を押すと、スクロール速度が倍増します。",
"Mouse Wheel Scroll Sensitivity": "マウス ホイール スクロール イベントの `deltaX` と `deltaY` で使用される乗数。",
"automatic keyboard navigation setting": "リストやツリーでのキーボード ナビゲーションを、単に入力するだけで自動的にトリガーするかどうかを制御します。`false` に設定した場合、キーボード ナビゲーションは `list.toggleKeyboardNavigation` コマンドを実行したときにのみトリガーされます。これに対してキーボード ショートカットを割り当てることができます。",
"defaultFindMatchTypeSettingKey": "ワークベンチでリストとツリーを検索するときに使用される一致の種類を制御します。",
"defaultFindMatchTypeSettingKey.contiguous": "検索時に連続一致を使用します。",
"defaultFindMatchTypeSettingKey.fuzzy": "検索時にあいまい一致を使用します。",
"defaultFindModeSettingKey": "ワークベンチのリストとツリーの既定の検索モードを制御します。",
"defaultFindModeSettingKey.filter": "検索時に要素をフィルター処理します。",
"defaultFindModeSettingKey.highlight": "検索時に要素を強調表示します。さらに上下のナビゲーションでは、強調表示された要素のみがスキャンされます。",
"expand mode": "フォルダー名をクリックしたときにツリー フォルダーが展開される方法を制御します。適用できない場合、一部のツリーやリストではこの設定が無視されることがあります。",
"horizontalScrolling setting": "リストとツリーがワークベンチで水平スクロールをサポートするかどうかを制御します。警告: この設定をオンにすると、パフォーマンスに影響があります。",
"keyboardNavigationSettingKey": "ワークベンチのリストおよびツリーのキーボード ナビゲーション スタイルを制御します。単純、強調表示、フィルターを指定できます。",
"keyboardNavigationSettingKey.filter": "キーボード ナビゲーションのフィルターでは、キーボード入力に一致しないすべての要素がフィルター処理され、非表示になります。",
"keyboardNavigationSettingKey.highlight": "キーボード ナビゲーションの強調表示を使用すると、キーボード入力に一致する要素が強調表示されます。上および下への移動は、強調表示されている要素のみを移動します。",
"keyboardNavigationSettingKey.simple": "簡単なキーボード ナビゲーションは、キーボード入力に一致する要素に焦点を当てます。一致処理はプレフィックスでのみ実行されます。",
"keyboardNavigationSettingKeyDeprecated": "代わりに 'workbench.list.defaultFindMode' と 'workbench.list.typeNavigationMode' を使用してください。",
"list smoothScrolling setting": "リストとツリーでスムーズ スクロールを使用するかどうかを制御します。",
"list.scrollByPage": "スクロールバーのクリックでページごとにスクロールするかどうかを制御します。",
"multiSelectModifier": "マウスを使用して項目を複数選択するときに使用する修飾キーです (たとえば、エクスプローラーでエディターと scm ビューを開くなど)。'横に並べて開く' マウス ジェスチャー (がサポートされている場合) は、複数選択の修飾キーと競合しないように調整されます。",
"multiSelectModifier.alt": "Windows および Linux 上の `Alt` キーと macOS 上の `Option` キーに割り当てます。",
"multiSelectModifier.ctrlCmd": "Windows および Linux 上の `Control` キーと macOS 上の `Command` キーに割り当てます。",
"openModeModifier": "マウスを使用して、ツリーとリスト内の項目を開く方法を制御します (サポートされている場合)。適用できない場合、一部のツリーやリストではこの設定が無視されることがあります。",
"render tree indent guides": "ツリーでインデントのガイドを表示するかどうかを制御します。",
"tree indent setting": "ツリーのインデントをピクセル単位で制御します。",
"typeNavigationMode": "ワークベンチのリストとツリーで型ナビゲーションがどのように機能するかを制御します。'trigger' に設定すると、'list.triggerTypeNavigation' コマンドの実行後に型ナビゲーションが開始されます。",
"workbenchConfigurationTitle": "ワークベンチ"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "警告"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "コマンド '{0}' でエラー ({1}) が発生しました",
"canNotRun": "コマンド '{0}' でエラーが発生しました",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "よく使用するもの",
"morecCommands": "その他のコマンド",
"recentlyUsed": "最近使用したもの"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "エディター コマンド",
"globalCommands": "グローバル コマンド",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "カスタム",
"inputModeEntry": "'Enter' を押して入力を確認するか 'Escape' を押して取り消します",
"inputModeEntryDescription": "{0} ('Enter' を押して確認するか 'Escape' を押して取り消します)",
"ok": "OK",
"quickInput.back": "戻る",
"quickInput.backWithKeybinding": "戻る ({0})",
"quickInput.checkAll": "すべてのチェック ボックスを切り替える",
"quickInput.countSelected": "{0} 個選択済み",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} 件の結果",
"quickInputBox.ariaLabel": "入力すると結果が絞り込まれます。"
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "クイック入力"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "クリックして '{0}' コマンドを実行"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "コントラストを強めるために、アクティブな他要素と隔てる追加の境界線。",
"activeLinkForeground": "アクティブなリンクの色。",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "階層リンクの項目の背景色。",
"breadcrumbsFocusForeground": "フォーカスされた階層リンクの項目の色。",
"breadcrumbsSelectedBackground": "階層項目ピッカーの背景色。",
"breadcrumbsSelectedForegound": "選択された階層リンクの項目の色。",
"breadcrumbsSelectedForeground": "選択された階層リンクの項目の色。",
"buttonBackground": "ボタンの背景色。",
"buttonBorder": "ボタンの境界線の色。",
"buttonForeground": "ボタンの前景色。",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "ボタンの 2 次的な背景色。",
"buttonSecondaryForeground": "ボタンの 2 次的な前景色。",
"buttonSecondaryHoverBackground": "ホバー時のボタンの 2 次的な背景色。",
"buttonSeparator": "ボタンの区切り記号の色。",
"chartsBlue": "グラフの視覚化に使用される青色。",
"chartsForeground": "グラフで使用される前景色。",
"chartsGreen": "グラフの視覚化に使用される緑色。",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "チェックボックス ウィジェットの背景色。",
"checkbox.border": "チェックボックス ウィジェットの境界線の色。",
"checkbox.foreground": "チェックボックス ウィジェットの前景色。",
"checkbox.select.background": "要素が選択されている場合のチェックボックス ウィジェットの背景色。",
"checkbox.select.border": "要素が選択されている場合のチェックボックス ウィジェットの境界線の色。",
"contrastBorder": "コントラストを強めるために、他の要素と隔てる追加の境界線。",
"descriptionForeground": "追加情報を提供する説明文の前景色、例:ラベル。",
"diffDiagonalFill": "差分エディターの対角線の塗りつぶし色。対角線の塗りつぶしは、横に並べて比較するビューで使用されます。",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "削除された行の余白の背景色。",
"diffEditorRemovedLines": "削除した行の背景色。この色は、基本装飾が非表示にならないよう不透明にすることはできません。",
"diffEditorRemovedOutline": "削除されたテキストの輪郭の色。",
"disabledForeground": "無効な要素の全体的な前景。この色は、コンポーネントによってオーバーライドされない場合にのみ使用されます。",
"dropdownBackground": "ドロップダウンの背景。",
"dropdownBorder": "ドロップダウンの境界線。",
"dropdownForeground": "ドロップダウンの前景。",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "ハイ コントラストの選択済みテキストの色。",
"editorSelectionHighlight": "選択範囲の同じコンテンツの領域の色。この色は、基本装飾が非表示にならないよう不透明にすることはできません。",
"editorSelectionHighlightBorder": "選択範囲と同じコンテンツの境界線の色。",
"editorStickyScrollBackground": "エディターの固定スクロールの背景色",
"editorStickyScrollHoverBackground": "エディターの固定スクロールのホバー背景色",
"editorWarning.background": "エディター内の警告テキストの背景色。この色は、基本装飾が非表示にならないよう不透明にすることはできません。",
"editorWarning.foreground": "エディターで警告を示す波線の前景色。",
"editorWidgetBackground": "検索/置換窓など、エディター ウィジェットの背景色。",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "リストおよびツリーの型フィルター ウェジェットの背景色。",
"listFilterWidgetNoMatchesOutline": "一致項目がない場合の、リストおよびツリーの型フィルター ウィジェットのアウトライン色。",
"listFilterWidgetOutline": "リストおよびツリーの型フィルター ウィジェットのアウトライン色。",
"listFilterWidgetShadow": "リストおよびツリーの型フィルター ウィジェットのシャドウ色。",
"listFocusAndSelectionOutline": "リスト/ツリーがアクティブで選択されている場合の、フォーカスされたアイテムのリスト/ツリー アウトラインの色。アクティブなリスト/ツリーにはキーボード フォーカスがあり、非アクティブな場合はありません。",
"listFocusBackground": "ツリーリストがアクティブのとき、フォーカスされた項目のツリーリスト背景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。",
"listFocusForeground": "ツリーリストがアクティブのとき、フォーカスされた項目のツリーリスト前景色。アクティブなツリーリストはキーボード フォーカスがあり、非アクティブではこれがありません。",
"listFocusHighlightForeground": "ツリー/リスト内を検索しているとき、一致した強調のツリー/リストの前景色。",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "アクションの上にマウス ポインターを合わせるとツール バーの背景が表示される",
"toolbarHoverBackground": "アクションの上にマウス ポインターを合わせたときのツール バーのアウトライン",
"toolbarHoverOutline": "アクションの上にマウス ポインターを合わせたときのツール バーのアウトライン",
"treeInactiveIndentGuidesStroke": "アクティブでないインデント ガイドのツリー ストロークの色。",
"treeIndentGuidesStroke": "インデント ガイドのツリー ストロークの色。",
"warningBorder": "エディターでの警告ボックスの境界線の色です。",
"widgetBorder": "エディター内の検索/置換窓など、エディター ウィジェットの境界線の色。",
"widgetShadow": "エディター内の検索/置換窓など、エディター ウィジェットの影の色。"
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "ウィジェットにある閉じるアクションのアイコン。"
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "キャンセル",
"cannotResourceRedoDueToInProgressUndoRedo": "元に戻すまたはやり直し操作が既に実行されているため、'{0}' をやり直すことはできませんでした。",
"cannotResourceUndoDueToInProgressUndoRedo": "元に戻すまたはやり直し操作が既に実行されているため、'{0}' を元に戻すことはできませんでした。",
"cannotWorkspaceRedo": "すべてのファイルで '{0}' をやり直しできませんでした。{1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "{1} で元に戻すまたはやり直し操作が既に実行されているため、すべてのファイルに対して '{0}' を元に戻すことはできませんでした",
"confirmDifferentSource": "'{0}' を元に戻しますか?",
"confirmDifferentSource.no": "いいえ",
"confirmDifferentSource.yes": "はい",
"confirmDifferentSource.yes": "はい(&&Y)",
"confirmWorkspace": "すべてのファイルで '{0}' を元に戻しますか?",
"externalRemoval": "次のファイルが閉じられ、ディスク上で変更されました: {0}。",
"noParallelUniverses": "以下のファイルは互換性のない方法で変更されました: {0}。",
"nok": "このファイルを元に戻す",
"ok": "{0} 個のファイルで元に戻す"
"ok": "{0} 個のファイルで元に戻す(&&U)"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "コード ワークスペース"

400
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/ko.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0}({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "더 많은 행동..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "대화 상자 닫기",
"dialogErrorMessage": "오류",
"dialogInfoMessage": "정보",
"dialogPendingMessage": "진행 중",
"dialogWarningMessage": "경고",
"ok": "확인"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "더 많은 작업..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "입력"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "대/소문자 구분",
"regexDescription": "정규식 사용",
"wordsDescription": "단어 단위로"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "입력",
"label.preserveCaseToggle": "대/소문자 보존"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "바인딩 안 됨"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Box 선택"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "기타 작업..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "지우기",
"disable filter on type": "형식을 기준으로 필터링 사용 안 함",
"empty": "찾은 요소 없음",
"enable filter on type": "형식을 기준으로 필터링 사용",
"found": "{1}개 요소 중 {0}개 일치"
"close": "닫기",
"filter": "필터",
"fuzzySearch": "유사 항목 일치",
"not found": "찾은 요소가 없습니다.",
"type to filter": "필터링할 형식",
"type to search": "입력하여 검색"
},
"vs/base/common/actions": {
"submenu.empty": "(비어 있음)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "사용자 지정",
"inputModeEntry": "입력을 확인하려면 'Enter' 키를 누르고, 취소하려면 'Esc' 키를 누르세요.",
"inputModeEntryDescription": "{0}(확인하려면 'Enter' 키를 누르고, 취소하려면 'Escape' 키를 누름)",
"ok": "확인",
"quickInput.back": "뒤로",
"quickInput.backWithKeybinding": "뒤로({0})",
"quickInput.countSelected": "{0} 선택됨",
"quickInput.steps": "{0} / {1}",
"quickInput.visibleCount": "{0}개 결과",
"quickInputBox.ariaLabel": "결과의 범위를 축소하려면 입력하세요."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "빠른 입력"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "현재 편집기에 액세스할 수 없습니다. 옵션을 보려면 {0}을(를) 누릅니다.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "실행 취소"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "커서 수는 {0}(으)로 제한되었습니다."
"cursors.maximum": "커서 수를 {0}개로 제한했습니다. 더 큰 변경 내용을 위해서는 [찾아서 교체](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace)를 사용하거나 편집기 다중 커서 제한 설정을 늘리는 것이 좋습니다.",
"goToSetting": "다중 커서 제한 늘리기"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " Shift + F7을 사용하여 변경 내용 탐색",
"diff.tooLarge": "파일 1개가 너무 커서 파일을 비교할 수 없습니다.",
"diffInsertIcon": "diff 편집기의 삽입에 대한 줄 데코레이션입니다.",
"diffRemoveIcon": "diff 편집기의 제거에 대한 줄 데코레이션입니다."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "편집기에서 CodeLens를 표시할 것인지 여부를 제어합니다.",
"detectIndentation": "파일을 열 때 파일 콘텐츠를 기반으로 `#editor.tabSize#`와 `#editor.insertSpaces#`가 자동으로 검색되는지 여부를 제어합니다.",
"detectIndentation": "파일 내용을 기반으로 파일을 열 때 {0} 및 {1}을(를) 자동으로 감지할지 여부를 제어합니다.",
"diffAlgorithm.experimental": "실험적 차이 알고리즘을 사용합니다.",
"diffAlgorithm.smart": "기본 차이 알고리즘을 사용합니다.",
"editor.experimental.asyncTokenization": "웹 작업자에서 토큰화가 비동기적으로 수행되어야 하는지 여부를 제어합니다.",
"editorConfigurationTitle": "편집기",
"ignoreTrimWhitespace": "사용하도록 설정하면 Diff 편집기가 선행 또는 후행 공백의 변경 내용을 무시합니다.",
"insertSpaces": "'탭' 키를 누를 때 공백을 삽입합니다. `#editor.detectIndentation#`이 켜져 있는 경우 이 설정은 파일 콘텐츠에 따라 재정의됩니다.",
"indentSize": "들여쓰기 또는 `\"tabSize\"에서 '#editor.tabSize#'의 값을 사용하는 데 사용되는 공백 수입니다. 이 설정은 '#editor.detectIndentation#'이 켜져 있는 경우 파일 내용에 따라 재정의됩니다.",
"insertSpaces": "`Tab`을 누를 때 공백을 삽입하세요. 이 설정은 {0}이(가) 켜져 있을 때 파일 내용을 기반으로 재정의됩니다.",
"largeFileOptimizations": "큰 파일에 대한 특수 처리로, 메모리를 많이 사용하는 특정 기능을 사용하지 않도록 설정합니다.",
"maxComputationTime": "diff 계산이 취소된 후 밀리초 단위로 시간을 제한합니다. 제한 시간이 없는 경우 0을 사용합니다.",
"maxFileSize": "차이를 계산할 최대 파일 크기(MB)입니다. 제한이 없으면 0을 사용합니다.",
"maxTokenizationLineLength": "이 길이를 초과하는 줄은 성능상의 이유로 토큰화되지 않습니다.",
"renderIndicators": "diff 편집기에서 추가/제거된 변경 내용에 대해 +/- 표시기를 표시하는지 여부를 제어합니다.",
"renderMarginRevertIcon": "활성화되면 diff 편집기는 변경 내용을 되돌리기 위해 글리프 여백에 화살표를 표시합니다.",
"schema.brackets": "들여쓰기를 늘리거나 줄이는 대괄호 기호를 정의합니다.",
"schema.closeBracket": "닫는 대괄호 문자 또는 문자열 시퀀스입니다.",
"schema.colorizedBracketPairs": "대괄호 쌍 색 지정을 사용하는 경우 중첩 수준에 따라 색이 지정된 대괄호 쌍을 정의합니다.",
@ -140,14 +161,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.true": "모든 색 테마에 대해 의미 체계 강조 표시를 사용합니다.",
"sideBySide": "diff 편집기에서 diff를 나란히 표시할지 인라인으로 표시할지를 제어합니다.",
"stablePeek": "해당 콘텐츠를 두 번 클릭하거나 'Esc' 키를 누르더라도 Peek 편집기를 열린 상태로 유지합니다.",
"tabSize": "탭 한 개에 해당하는 공백 수입니다. `#editor.detectIndentation#`이 켜져 있는 경우 이 설정은 파일 콘텐츠에 따라 재정의됩니다.",
"tabSize": "탭이 같은 공백의 수입니다. 이 설정은 {0}이(가) 켜져 있을 때 파일 내용을 기반으로 재정의됩니다.",
"trimAutoWhitespace": "끝에 자동 삽입된 공백을 제거합니다.",
"wordBasedSuggestions": "문서 내 단어를 기반으로 완성을 계산할지 여부를 제어합니다.",
"wordBasedSuggestionsMode": "단어 기반 완성이 컴퓨팅되는 문서에서 제어합니다.",
"wordBasedSuggestionsMode.allDocuments": "모든 열린 문서에서 단어를 제안합니다.",
"wordBasedSuggestionsMode.currentDocument": "활성 문서에서만 단어를 제안합니다.",
"wordBasedSuggestionsMode.matchingDocuments": "같은 언어의 모든 열린 문서에서 단어를 제안합니다.",
"wordWrap.inherit": "`#editor.wordWrap#` 설정에 따라 줄이 바뀝니다.",
"wordWrap.inherit": "줄은 {0} 설정에 따라 줄 바꿈됩니다.",
"wordWrap.off": "줄이 바뀌지 않습니다.",
"wordWrap.on": "뷰포트 너비에서 줄이 바뀝니다."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "'Tab' 키 외에 'Enter' 키에 대한 제안도 허용할지를 제어합니다. 새 줄을 삽입하는 동작과 제안을 허용하는 동작 간의 모호함을 없앨 수 있습니다.",
"acceptSuggestionOnEnterSmart": "텍스트를 변경할 때 `Enter` 키를 사용한 제안만 허용합니다.",
"accessibilityPageSize": "화면 읽기 프로그램에서 한 번에 읽을 수 있는 편집기 줄 수를 제어합니다. 화면 읽기 프로그램을 검색하면 기본값이 500으로 자동 설정됩니다. 경고: 기본값보다 큰 수의 경우 성능에 영향을 미칩니다.",
"accessibilitySupport": "편집기를 화면 읽기 프로그램에 최적화된 모드로 실행할지 여부를 제어합니다. 사용하도록 설정하면 자동 줄 바꿈이 사용하지 않도록 설정됩니다.",
"accessibilitySupport.auto": "편집기가 스크린 리더가 연결되면 플랫폼 API를 사용하여 감지합니다.",
"accessibilitySupport.off": "편집기가 스크린 리더 사용을 위해 최적화되지 않습니다.",
"accessibilitySupport.on": "편집기가 화면 읽기 프로그램과 함께 사용되도록 영구적으로 최적화되며, 자동 줄 바꿈이 사용하지 않도록 설정됩니다.",
"accessibilitySupport": "화면 판독기에 최적화된 모드에서 UI를 실행해야 하는지 여부를 제어합니다.",
"accessibilitySupport.auto": "플랫폼 API를 사용하여 화면 읽기 프로그램이 연결된 경우 감지",
"accessibilitySupport.off": "화면 읽기 프로그램이 연결되어 있지 않다고 가정",
"accessibilitySupport.on": "화면 읽기 프로그램을 사용하여 사용 최적화",
"alternativeDeclarationCommand": "'선언으로 이동'의 결과가 현재 위치일 때 실행되는 대체 명령 ID입니다.",
"alternativeDefinitionCommand": "'정의로 이동'의 결과가 현재 위치일 때 실행되는 대체 명령 ID입니다.",
"alternativeImplementationCommand": "'구현으로 이동'의 결과가 현재 위치일 때 실행되는 대체 명령 ID입니다.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "사용자가 여는 따옴표를 추가한 후 편집기에서 따옴표를 자동으로 닫을지 여부를 제어합니다.",
"autoIndent": "사용자가 줄을 입력, 붙여넣기, 이동 또는 들여쓰기 할 때 편집기에서 들여쓰기를 자동으로 조정하도록 할지 여부를 제어합니다.",
"autoSurround": "따옴표 또는 대괄호 입력 시 편집기가 자동으로 선택 영역을 둘러쌀지 여부를 제어합니다.",
"bracketPairColorization.enabled": "브래킷 쌍 색상화가 활성화되었는지 여부를 제어합니다. 브래킷 하이라이트 색상을 재정의하려면 `#workbench.colorCustomizations#`를 사용하세요.",
"bracketPairColorization.enabled": "대괄호 쌍 색 지정을 사용할지 여부를 제어합니다. {0}을(를) 사용하여 대괄호 강조 색을 재정의합니다.",
"bracketPairColorization.independentColorPoolPerBracketType": "각 대괄호 형식에 고유한 독립적인 색 풀이 있는지 여부를 제어합니다.",
"codeActions": "편집기에서 코드 동작 전구를 사용하도록 설정합니다.",
"codeLens": "편집기에서 CodeLens를 표시할 것인지 여부를 제어합니다.",
"codeLensFontFamily": "CodeLens의 글꼴 패밀리를 제어합니다.",
"codeLensFontSize": "CodeLens의 글꼴 크기(픽셀)를 제어합니다. '0'으로 설정하면 `#editor.fontSize#`의 90%가 사용됩니다.",
"codeLensFontSize": "CodeLens의 글꼴 크기(픽셀)를 제어합니다. 0으로 설정하면 `#editor.fontSize#`의 90%가 사용됩니다.",
"colorDecorators": "편집기에서 인라인 색 데코레이터 및 색 선택을 렌더링할지를 제어합니다.",
"colorDecoratorsLimit": "편집기에서 한 번에 렌더링할 수 있는 최대 색 데코레이터 수를 제어합니다.",
"columnSelection": "마우스와 키로 선택한 영역에서 열을 선택하도록 설정합니다.",
"comments.ignoreEmptyLines": "빈 줄을 줄 주석에 대한 토글, 추가 또는 제거 작업으로 무시해야 하는지를 제어합니다.",
"comments.insertSpace": "주석을 달 때 공백 문자를 삽입할지 여부를 제어합니다.",
"copyWithSyntaxHighlighting": "구문 강조 표시를 클립보드로 복사할지 여부를 제어합니다.",
"cursorBlinking": "커서 애니메이션 스타일을 제어합니다.",
"cursorSmoothCaretAnimation": "매끄러운 캐럿 애니메이션의 사용 여부를 제어합니다.",
"cursorSmoothCaretAnimation.explicit": "부드러운 캐럿 애니메이션은 사용자가 명시적 제스처를 사용하여 커서를 이동할 때만 사용됩니다.",
"cursorSmoothCaretAnimation.off": "부드러운 캐럿 애니메이션을 사용할 수 없습니다.",
"cursorSmoothCaretAnimation.on": "부드러운 캐럿 애니메이션은 항상 사용됩니다.",
"cursorStyle": "커서 스타일을 제어합니다.",
"cursorSurroundingLines": "커서 주위에 표시되는 선행 및 후행 줄의 최소 수를 제어합니다. 일부 다른 편집기에서는 'scrollOff' 또는 'scrollOffset'이라고 합니다.",
"cursorSurroundingLines": "커서 주변에 표시되는 선행 줄(최소 0)과 후행 줄(최소 1)의 최소 수를 제어합니다. 일부 다른 편집기에서는 'scrollOff' 또는 'scrollOffset'으로 알려져 있습니다.",
"cursorSurroundingLinesStyle": "'cursorSurroundingLines'를 적용해야 하는 경우를 제어합니다.",
"cursorSurroundingLinesStyle.all": "`cursorSurroundingLines`는 항상 적용됩니다.",
"cursorSurroundingLinesStyle.default": "'cursorSurroundingLines'는 키보드 나 API를 통해 트리거될 때만 적용됩니다.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "이동 정의 마우스 제스처가 항상 미리 보기 위젯을 열지 여부를 제어합니다.",
"deprecated": "이 설정은 더 이상 사용되지 않습니다. 대신 'editor.suggest.showKeywords'또는 'editor.suggest.showSnippets'와 같은 별도의 설정을 사용하세요.",
"dragAndDrop": "편집기에서 끌어서 놓기로 선택 영역을 이동할 수 있는지 여부를 제어합니다.",
"dropIntoEditor.enabled": "편집기에서 파일을 여는 대신 `shift`를 누른 채 파일을 텍스트 편집기로 끌어서 놓을 수 있는지 여부를 제어합니다.",
"editor.autoClosingBrackets.beforeWhitespace": "커서가 공백의 왼쪽에 있는 경우에만 대괄호를 자동으로 닫습니다.",
"editor.autoClosingBrackets.languageDefined": "언어 구성을 사용하여 대괄호를 자동으로 닫을 경우를 결정합니다.",
"editor.autoClosingDelete.auto": "인접한 닫는 따옴표 또는 대괄호가 자동으로 삽입된 경우에만 제거합니다.",
@ -219,10 +245,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.find.seedSearchStringFromSelection.never": "편집기 선택 영역에서 검색 문자열을 시드하지 마세요.",
"editor.find.seedSearchStringFromSelection.selection": "편집기 선택 영역에서만 검색 문자열을 시드하세요.",
"editor.gotoLocation.multiple.deprecated": "이 설정은 더 이상 사용되지 않습니다. 대신 'editor.editor.gotoLocation.multipleDefinitions' 또는 'editor.editor.gotoLocation.multipleImplementations'와 같은 별도의 설정을 사용하세요.",
"editor.gotoLocation.multiple.goto": "기본 결과로 이동하고 다른 항목에 대해 peek 없는 탐색을 사용하도록 설정",
"editor.gotoLocation.multiple.goto": "기본 결과로 이동하여 다른 항목에 대해 Peek 없는 탐색을 사용하도록 설정합니다.",
"editor.gotoLocation.multiple.gotoAndPeek": "기본 결과로 이동하여 Peek 보기를 표시합니다.",
"editor.gotoLocation.multiple.peek": "결과 Peek 뷰 표시(기본)",
"editor.guides.bracketPairs": "대괄호 쌍 안내션의 사용 여부를 제어합니다.",
"editor.gotoLocation.multiple.peek": "결과의 Peek 보기 표시(기본값)",
"editor.guides.bracketPairs": "대괄호 쌍 안내선의 사용 여부를 제어합니다.",
"editor.guides.bracketPairs.active": "활성 대괄호 쌍에 대해서만 대괄호 쌍 가이드를 사용하도록 설정합니다.",
"editor.guides.bracketPairs.false": "대괄호 쌍 가이드를 비활성화합니다.",
"editor.guides.bracketPairs.true": "대괄호 쌍 가이드를 사용하도록 설정합니다.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "수직 대괄호 쌍 가이드에 추가하여 수평 가이드를 사용하도록 설정합니다.",
"editor.guides.highlightActiveBracketPair": "편집기가 활성 브래킷 쌍을 강조 표시해야 하는지 여부를 제어합니다.",
"editor.guides.highlightActiveIndentation": "편집기에서 활성 들여쓰기 가이드를 강조 표시할지 여부를 제어합니다.",
"editor.guides.highlightActiveIndentation.always": "브래킷 안내선이 강조 표시된 경우에도 활성 들여쓰기 안내선을 강조 표시합니다.",
"editor.guides.highlightActiveIndentation.false": "활성 들여쓰기 안내선을 강조 표시하지 마세요.",
"editor.guides.highlightActiveIndentation.true": "활성 들여쓰기 안내선을 강조 표시합니다.",
"editor.guides.indentation": "편집기에서 들여쓰기 가이드를 렌더링할지를 제어합니다.",
"editor.inlayHints.off": "인레이 힌트는 사용할 수 없음",
"editor.inlayHints.offUnlessPressed": "인레이 힌트는 기본값으로 숨겨져 있으며 {0}을(를) 길게 누르면 표시됩니다.",
"editor.inlayHints.on": "인레이 힌트를 사용할 수 있음",
"editor.inlayHints.onUnlessPressed": "인레이 힌트는 기본적으로 표시되고 {0}을(를) 길게 누를 때 숨겨집니다.",
"editor.stickyScroll": "편집기 위쪽에서 스크롤하는 동안 중첩된 현재 범위를 표시합니다.",
"editor.stickyScroll.": "표시할 최대 고정 선 수를 정의합니다.",
"editor.suggest.matchOnWordStartOnly": "IntelliSense 필터링을 활성화하면 첫 번째 문자가 단어 시작 부분과 일치해야 합니다(예: `c`의 경우 `Console` 또는 `WebContext`가 될 수 있으며 `description`은 _안 됨_). 비활성화하면 IntelliSense가 더 많은 결과를 표시하지만 여전히 일치 품질을 기준으로 정렬합니다.",
"editor.suggest.showClasss": "사용하도록 설정되면 IntelliSense에 '클래스' 제안이 표시됩니다.",
"editor.suggest.showColors": "사용하도록 설정되면 IntelliSense에 '색' 제안이 표시됩니다.",
"editor.suggest.showConstants": "사용하도록 설정되면 IntelliSense에 '상수' 제안이 표시됩니다.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "사용하도록 설정되면 IntelliSense에 '변수' 제안이 표시됩니다.",
"editorViewAccessibleLabel": "편집기 콘텐츠",
"emptySelectionClipboard": "선택 영역 없이 현재 줄 복사 여부를 제어합니다.",
"experimentalWhitespaceRendering": "공백이 새로운 실험적 메서드로 렌더링되는지 여부를 제어합니다.",
"experimentalWhitespaceRendering.font": "글꼴 문자와 함께 새 렌더링 방법을 사용합니다.",
"experimentalWhitespaceRendering.off": "안정적인 렌더링 방법을 사용합니다.",
"experimentalWhitespaceRendering.svg": "svgs와 함께 새 렌더링 메서드를 사용합니다.",
"fastScrollSensitivity": "'Alt' 키를 누를 때 스크롤 속도 승수입니다.",
"find.addExtraSpaceOnTop": "위젯 찾기에서 편집기 맨 위에 줄을 추가해야 하는지 여부를 제어합니다. true인 경우 위젯 찾기가 표시되면 첫 번째 줄 위로 스크롤할 수 있습니다.",
"find.autoFindInSelection": "선택 영역에서 찾기를 자동으로 설정하는 조건을 제어합니다.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "글꼴 합자('calt' 및 'liga' 글꼴 기능)를 사용하거나 사용하지 않도록 설정합니다. 'font-feature-settings' CSS 속성의 세분화된 제어를 위해 문자열로 변경합니다.",
"fontLigaturesGeneral": "글꼴 합자 또는 글꼴 기능을 구성합니다. CSS 'font-feature-settings' 속성의 값에 대해 합자 또는 문자열을 사용하거나 사용하지 않도록 설정하기 위한 부울일 수 있습니다.",
"fontSize": "글꼴 크기(픽셀)를 제어합니다.",
"fontVariationSettings": "명시적 'font-variation-settings' CSS 속성입니다. font-weight만 font-variation-settings로 변환해야 하는 경우 부울을 대신 전달할 수 있습니다.",
"fontVariations": "font-weight에서 font-variation-settings로 변환을 사용/사용하지 않습니다. 'font-variation-settings' CSS 속성의 세분화된 컨트롤을 위해 이를 문자열로 변경합니다.",
"fontVariationsGeneral": "글꼴 변형을 구성합니다. font-weight에서 font-variation-settings로 변환을 사용/사용하지 않도록 설정하는 부울이거나 CSS 'font-variation-settings' 속성 값에 대한 문자열일 수 있습니다.",
"fontWeight": "글꼴 두께를 제어합니다. \"표준\" 및 \"굵게\" 키워드 또는 1~1000 사이의 숫자를 허용합니다.",
"fontWeightErrorMessage": "\"표준\" 및 \"굵게\" 키워드 또는 1~1000 사이의 숫자만 허용됩니다.",
"formatOnPaste": "붙여넣은 콘텐츠의 서식을 편집기에서 자동으로 지정할지 여부를 제어합니다. 포맷터를 사용할 수 있어야 하며 포맷터가 문서에서 범위의 서식을 지정할 수 있어야 합니다.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "호버 표시 여부를 제어합니다.",
"hover.sticky": "마우스를 해당 항목 위로 이동할 때 호버를 계속 표시할지 여부를 제어합니다.",
"inlayHints.enable": "편집기에서 인레이 힌트를 사용하도록 설정합니다.",
"inlayHints.fontFamily": "편집기에서 인레이 힌트의 글꼴 모음을 제어합니다. 공백으로 설정하면 `#editor.fontFamily#`가 사용됩니다.",
"inlayHints.fontSize": "편집기에서 인레이 힌트의 글꼴 크기를 제어합니다. 기본값인 `#editor.fontSize#`의 90%는 구성된 값이 `5`보다 작거나 편집기 글꼴 크기보다 큰 경우 사용됩니다.",
"inlayHints.fontFamily": "편집기에서 인레이 힌트의 글꼴 패밀리를 제어합니다. 비워 두면 {0}이(가) 사용됩니다.",
"inlayHints.fontSize": "편집기에서 인레이 힌트의 글꼴 크기를 제어합니다. 기본적으로 {0}은(는) 구성된 값이 {1}보다 작거나 편집기 글꼴 크기보다 큰 경우에 사용됩니다.",
"inlayHints.padding": "편집기에서 인레이 힌트 주위의 패딩을 사용하도록 설정합니다.",
"inline": "빠른 제안이 유령 텍스트로 표시됨",
"inlineSuggest.enabled": "편집기에서 인라인 제안을 자동으로 표시할지 여부를 제어합니다.",
"inlineSuggest.showToolbar": "인라인 추천 도구 모음을 표시할 시기를 제어합니다.",
"inlineSuggest.showToolbar.always": "인라인 추천을 표시힐 때마다 인라인 추천 도구 모음을 표시합니다.",
"inlineSuggest.showToolbar.onHover": "인라인 추천을 마우스로 가리키면 인라인 추천 도구 모음을 표시합니다.",
"letterSpacing": "문자 간격(픽셀)을 제어합니다.",
"lineHeight": "선 높이를 제어합니다. \r\n - 0을 사용하여 글꼴 크기에서 줄 높이를 자동으로 계산합니다.\r\n - 0에서 8 사이의 값은 글꼴 크기의 승수로 사용됩니다.\r\n - 8보다 크거나 같은 값이 유효 값으로 사용됩니다.",
"lineNumbers": "줄 번호의 표시 여부를 제어합니다.",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "편집기에서 연결된 편집이 사용하도록 설정되었는지를 제어합니다. 언어에 따라 관련 기호(예: HTML 태그)가 편집 중에 업데이트됩니다.",
"links": "편집기에서 링크를 감지하고 클릭할 수 있게 만들지 여부를 제어합니다.",
"matchBrackets": "일치하는 대괄호를 강조 표시합니다.",
"minimap.autohide": "미니맵을 자동으로 숨길지 여부를 제어합니다.",
"minimap.enabled": "미니맵 표시 여부를 제어합니다.",
"minimap.maxColumn": "최대 특정 수의 열을 렌더링하도록 미니맵의 너비를 제한합니다.",
"minimap.renderCharacters": "줄의 실제 문자(색 블록 아님)를 렌더링합니다.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "미니맵의 크기는 편집기 내용과 동일하며 스크롤할 수 있습니다.",
"mouseWheelScrollSensitivity": "마우스 휠 스크롤 이벤트의 `deltaX` 및 `deltaY`에서 사용할 승수입니다.",
"mouseWheelZoom": "마우스 휠을 사용할 때 'Ctrl' 키를 누르고 있으면 편집기의 글꼴을 확대/축소합니다.",
"multiCursorLimit": "한 번에 활성 편집기에 있을 수 있는 최대 커서 수를 제어합니다.",
"multiCursorMergeOverlapping": "여러 커서가 겹치는 경우 커서를 병합합니다.",
"multiCursorModifier": "마우스로 여러 커서를 추가할 때 사용할 수정자입니다. [정의로 이동] 및 [링크 열기] 마우스 제스처가 멀티커서 수정자와 충돌하지 않도록 조정됩니다. [자세한 정보](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "마우스로 여러 커서를 추가할 때 사용할 수정자입니다. [정의로 이동] 및 [링크 열기] 마우스 제스처가 [멀티커서 수정자와](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier) 충돌하지 않도록 조정됩니다.",
"multiCursorModifier.alt": "Windows와 Linux의 'Alt'를 macOS의 'Option'으로 매핑합니다.",
"multiCursorModifier.ctrlCmd": "Windows와 Linux의 'Control'을 macOS의 'Command'로 매핑합니다.",
"multiCursorPaste": "붙여넣은 텍스트의 줄 수가 커서 수와 일치하는 경우 붙여넣기를 제어합니다.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "미리 보기 위젯에서 인라인 편집기에 포커스를 둘지 또는 트리에 포커스를 둘지를 제어합니다.",
"peekWidgetDefaultFocus.editor": "미리 보기를 열 때 편집기에 포커스",
"peekWidgetDefaultFocus.tree": "Peek를 여는 동안 트리에 포커스",
"quickSuggestions": "입력하는 동안 제안을 자동으로 표시할지 여부를 제어합니다.",
"quickSuggestions": "입력하는 동안 제안을 자동으로 표시할지 여부를 제어합니다. 이것은 주석, 문자열 및 기타 코드를 입력하기 위해 제어할 수 있습니다. 빠른 제안은 고스트 텍스트 또는 제안 위젯으로 표시하도록 구성할 수 있습니다. 또한 제안이 특수 문자에 의해 실행되는지 여부를 제어하는 '{0}'-설정에 유의하세요.",
"quickSuggestions.comments": "주석 내에서 빠른 제안을 사용합니다.",
"quickSuggestions.other": "문자열 및 주석 외부에서 빠른 제안을 사용합니다.",
"quickSuggestions.strings": "문자열 내에서 빠른 제안을 사용합니다.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "여백의 접기 컨트롤이 표시되는 시기를 제어합니다.",
"showFoldingControls.always": "접기 컨트롤을 항상 표시합니다.",
"showFoldingControls.mouseover": "마우스가 여백 위에 있을 때에만 접기 컨트롤을 표시합니다.",
"showFoldingControls.never": "접기 컨트롤을 표시하지 않고 여백 크기를 줄이세요.",
"showUnused": "사용하지 않는 코드의 페이드 아웃을 제어합니다.",
"smoothScrolling": "편집기에서 애니메이션을 사용하여 스크롤할지 여부를 제어합니다.",
"snippetSuggestions": "코드 조각이 다른 추천과 함께 표시되는지 여부 및 정렬 방법을 제어합니다.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "들여쓰기에 공백을 사용할 때 탭 문자의 선택 동작을 에뮬레이트합니다. 선택 영역이 탭 정지에 고정됩니다.",
"suggest.filterGraceful": "제안 필터링 및 정렬에서 작은 오타를 설명하는지 여부를 제어합니다.",
"suggest.insertMode": "완료를 수락할 때 단어를 덮어쓸지 여부를 제어합니다. 이것은 이 기능을 선택하는 확장에 따라 다릅니다.",
"suggest.insertMode.always": "IntelliSense를 자동으로 트리거할 때 항상 제안을 선택합니다.",
"suggest.insertMode.insert": "커서의 텍스트 오른쪽을 덮어 쓰지않고 제안을 삽입합니다.",
"suggest.insertMode.never": "IntelliSense를 자동으로 트리거할 때 제안을 선택하지 마세요.",
"suggest.insertMode.replace": "제안을 삽입하고 커서의 오른쪽 텍스트를 덮어씁니다.",
"suggest.insertMode.whenQuickSuggestion": "입력할 때 IntelliSense를 트리거할 때만 제안을 선택합니다.",
"suggest.insertMode.whenTriggerCharacter": "트리거 문자에서 IntelliSense를 트리거할 때만 제안을 선택합니다.",
"suggest.localityBonus": "정렬할 때 커서 근처에 표시되는 단어를 우선할지를 제어합니다.",
"suggest.maxVisibleSuggestions.dep": "이 설정은 더 이상 사용되지 않습니다. 이제 제안 위젯의 크기를 조정할 수 있습니다.",
"suggest.preview": "편집기에서 제안 결과를 미리볼지 여부를 제어합니다.",
"suggest.selectionMode": "위젯이 표시될 때 제안을 선택할지 여부를 제어합니다. 이는 자동으로 트리거된 제안('#editor.quickSuggestions#' 및 '#editor.suggestOnTriggerCharacters#')에만 적용되며, 제안이 명시적으로 호출될 때 항상 선택됩니다(예: 'Ctrl+Space'를 통해).",
"suggest.shareSuggestSelections": "저장된 제안 사항 선택 항목을 여러 작업 영역 및 창에서 공유할 것인지 여부를 제어합니다(`#editor.suggestSelection#` 필요).",
"suggest.showIcons": "제안의 아이콘을 표시할지 여부를 제어합니다.",
"suggest.showInlineDetails": "제안 세부 정보가 레이블과 함께 인라인에 표시되는지 아니면 세부 정보 위젯에만 표시되는지를 제어합니다.",
"suggest.showStatusBar": "제안 위젯 하단의 상태 표시줄 가시성을 제어합니다.",
"suggest.snippetsPreventQuickSuggestions": "활성 코드 조각이 빠른 제안을 방지하는지 여부를 제어합니다.",
"suggestFontSize": "제안 위젯의 글꼴 크기입니다. '0'으로 설정하면 '#editor.fontSize#'의 값이 사용됩니다.",
"suggestLineHeight": "제안 위젯의 줄 높이입니다. '0'으로 설정하면 `#editor.lineHeight#`의 값이 사용됩니다. 최솟값은 8입니다.",
"suggestFontSize": "제안 위젯의 글꼴 크기입니다. {0}(으)로 설정하면 {1} 값이 사용됩니다.",
"suggestLineHeight": "제안 위젯의 줄 높이입니다. {0}(으)로 설정하면 {1} 값이 사용됩니다. 최소값은 8입니다.",
"suggestOnTriggerCharacters": "트리거 문자를 입력할 때 제안을 자동으로 표시할지 여부를 제어합니다.",
"suggestSelection": "제안 목록을 표시할 때 제한이 미리 선택되는 방식을 제어합니다.",
"suggestSelection.first": "항상 첫 번째 제안을 선택합니다.",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "탭 완성을 사용하지 않도록 설정합니다.",
"tabCompletion.on": "탭 완료는 탭을 누를 때 가장 일치하는 제안을 삽입합니다.",
"tabCompletion.onlySnippets": "접두사가 일치하는 경우 코드 조각을 탭 완료합니다. 'quickSuggestions'를 사용하지 않을 때 가장 잘 작동합니다.",
"tabFocusMode": "편집기에서 탭을 받을지 또는 탐색을 위해 워크벤치로 미룰지를 제어합니다.",
"unfoldOnClickAfterEndOfLine": "접힌 줄이 줄을 펼친 후 빈 콘텐츠를 클릭할지 여부를 제어합니다.",
"unicodeHighlight.allowedCharacters": "강조 표시되지 않는 허용된 문자를 정의합니다.",
"unicodeHighlight.allowedLocales": "허용된 로캘에서 공통적인 유니코드 문자는 강조 표시되지 않습니다.",
"unicodeHighlight.ambiguousCharacters": "현재 사용자 로캘에서 공통되는 문자를 제외한 기본 ASCII 문자와 혼동할 수 있는 문자를 강조 표시할지 여부를 제어합니다.",
"unicodeHighlight.includeComments": "주석의 문자도 유니코드 강조 표시를 받아야 하는지 여부를 제어합니다.",
"unicodeHighlight.includeStrings": "문자열의 문자도 유니코드 강조 표시를 받아야 하는지 여부를 제어합니다.",
"unicodeHighlight.includeComments": "주석의 문자에도 유니코드 강조 표시를 적용해야 하는지 여부를 제어합니다.",
"unicodeHighlight.includeStrings": "문자열의 문자에도 유니코드 강조 표시를 적용해야 하는지 여부를 제어합니다.",
"unicodeHighlight.invisibleCharacters": "공백만 예약하거나 너비가 전혀 없는 문자를 강조 표시할지 여부를 제어합니다.",
"unicodeHighlight.nonBasicASCII": "기본이 아닌 모든 ASCII 문자를 강조 표시할지 여부를 제어합니다. U+0020과 U+007E 사이의 문자, 탭, 줄 바꿈 및 캐리지 리턴만 기본 ASCII로 간주됩니다.",
"unusualLineTerminators": "문제를 일으킬 수 있는 비정상적인 줄 종결자를 제거합니다.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "비정상적인 줄 종결자가 무시됩니다.",
"unusualLineTerminators.prompt": "제거할 비정상적인 줄 종결자 프롬프트입니다.",
"useTabStops": "탭 정지 뒤에 공백을 삽입 및 삭제합니다.",
"wordBreak": "중국어/일본어/한국어(CJK) 텍스트에 사용되는 단어 분리 규칙을 제어합니다.",
"wordBreak.keepAll": "단어 분리는 중국어/일본어/한국어(CJK) 텍스트에 사용할 수 없습니다. CJK가 아닌 텍스트 동작은 일반 텍스트 동작과 같습니다.",
"wordBreak.normal": "기본 줄 바꿈 규칙을 사용합니다.",
"wordSeparators": "단어 관련 탐색 또는 작업을 수행할 때 단어 구분 기호로 사용할 문자입니다.",
"wordWrap": "줄 바꿈 여부를 제어합니다.",
"wordWrap.bounded": "뷰포트의 최소값 및 `#editor.wordWrapColumn#`에서 줄이 바뀝니다.",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "줄 바꿈 행이 부모 쪽으로 +1만큼 들여쓰기됩니다.",
"wrappingIndent.none": "들여쓰기가 없습니다. 줄 바꿈 행이 열 1에서 시작됩니다.",
"wrappingIndent.same": "줄 바꿈 행의 들여쓰기가 부모와 동일합니다.",
"wrappingStrategy": "래핑 점을 계산하는 알고리즘을 제어합니다.",
"wrappingStrategy": "래핑 지점을 계산하는 알고리즘을 제어합니다. 접근성 모드에서는 최상의 환경을 위해 고급 기능이 사용됩니다.",
"wrappingStrategy.advanced": "래핑 점 계산을 브라우저에 위임합니다. 이 알고리즘은 매우 느려서 대용량 파일의 경우 중단될 수 있지만 모든 경우에 적절히 작동합니다.",
"wrappingStrategy.simple": "모든 문자가 동일한 너비라고 가정합니다. 이 알고리즘은 고정 폭 글꼴과 문자 모양의 너비가 같은 특정 스크립트(예: 라틴 문자)에 적절히 작동하는 빠른 알고리즘입니다."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "비활성 대괄호 쌍 안내선의 배경색입니다(6). 대괄호 쌍 안내선을 사용하도록 설정해야 합니다.",
"editorCodeLensForeground": "편집기 코드 렌즈의 전경색입니다.",
"editorCursorBackground": "편집기 커서의 배경색입니다. 블록 커서와 겹치는 글자의 색상을 사용자 정의할 수 있습니다.",
"editorDimmedLineNumber": "editor.renderFinalNewline이 흐리게 설정된 경우 최종 편집기 줄의 색입니다.",
"editorGhostTextBackground": "편집기에서 고스트 텍스트의 배경색입니다.",
"editorGhostTextBorder": "편집기에서 고스트 텍스트의 테두리 색입니다.",
"editorGhostTextForeground": "편집기에서 고스트 텍스트의 전경색입니다.",
"editorGutter": "편집기 거터의 배경색입니다. 거터에는 글리프 여백과 행 수가 있습니다.",
"editorIndentGuides": "편집기 들여쓰기 안내선 색입니다.",
"editorLineNumbers": "편집기 줄 번호 색입니다.",
"editorOverviewRulerBackground": "편집기 개요 눈금자의 배경색입니다. 미니맵이 사용하도록 설정되어 편집기의 오른쪽에 배치된 경우에만 사용됩니다.",
"editorOverviewRulerBackground": "편집기 개요 눈금자의 배경색입니다.",
"editorOverviewRulerBorder": "개요 눈금 경계의 색상입니다.",
"editorRuler": "편집기 눈금의 색상입니다.",
"editorUnicodeHighlight.background": "유니코드 문자를 강조 표시하는 데 사용되는 배경색입니다.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "현재 편집기에서 <Tab> 키를 누르면 포커스가 다음 포커스 가능한 요소로 이동합니다. {0} 명령은 현재 키 바인딩으로 트리거할 수 없습니다.",
"toggleHighContrast": "고대비 테마로 전환"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0}자",
"showMore": "자세히 표시({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "{0}에 설정된 앵커: {1}",
"cancelSelectionAnchor": "선택 앵커 지점 취소",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "다음으로 복사",
"miCopy": "복사(&&C)",
"miCut": "잘라내기(&&T)",
"miPaste": "붙여넣기(&&P)"
"miPaste": "붙여넣기(&&P)",
"share": "공유"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "코드 작업을 적용하는 중 알 수 없는 오류가 발생했습니다."
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "코드 작업을 적용하는 중 알 수 없는 오류가 발생했습니다.",
"args.schema.apply": "반환된 작업이 적용되는 경우를 제어합니다.",
"args.schema.apply.first": "항상 반환된 첫 번째 코드 작업을 적용합니다.",
"args.schema.apply.ifSingle": "첫 번째 반환된 코드 작업을 적용합니다(이 작업만 있는 경우).",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "가져오기 구성",
"quickfix.trigger.label": "빠른 수정...",
"refactor.label": "리팩터링...",
"refactor.preview.label": "미리 보기로 리팩터링...",
"source.label": "소스 작업..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "코드 작업 메뉴에 그룹 헤더 표시를 활성화/비활성화합니다."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "다시 쓰기",
"codeAction.widget.id.extract": "추출...",
"codeAction.widget.id.inline": "인라인...",
"codeAction.widget.id.more": "추가 작업...",
"codeAction.widget.id.move": "이동...",
"codeAction.widget.id.quickfix": "빠른 수정...",
"codeAction.widget.id.source": "소스 작업...",
"codeAction.widget.id.surround": "코드 감싸기..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "사용하지 않는 항목 숨기기",
"showMoreActions": "비활성화된 항목 표시"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "코드 작업 표시",
"codeActionWithKb": "코드 작업 표시({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "줄 주석 설정/해제(&&T)"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "편집기 상황에 맞는 메뉴 표시"
"action.showContextMenu.label": "편집기 상황에 맞는 메뉴 표시",
"context.minimap.minimap": "미니맵",
"context.minimap.renderCharacters": "문자 렌더링",
"context.minimap.size": "세로 크기",
"context.minimap.size.fill": "채우기",
"context.minimap.size.fit": "맞춤",
"context.minimap.size.proportional": "비례",
"context.minimap.slider": "슬라이더",
"context.minimap.slider.always": "항상",
"context.minimap.slider.mouseover": "마우스 위로"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "붙여넣을 때 확장에서 편집 실행을 사용하거나 사용하지 않도록 설정합니다."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "붙여넣기 처리기를 실행하는 중..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "커서 다시 실행",
"cursor.undo": "커서 실행 취소"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "드롭 처리기를 실행하는 중..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "편집기에서 취소 가능한 작업(예: '참조 피킹')을 실행하는지 여부"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "\"Math Case\" 플래그를 재정의합니다.\r\n플래그는 미래를 위해 저장되지 않습니다.\r\n0: 아무것도 하지 않음\r\n1: True\r\n2: False",
"actions.find.preserveCaseOverride": "\"케이스 보존\" 플래그를 재정의합니다.\r\n플래그는 미래를 위해 저장되지 않습니다.\r\n0: 아무것도 하지 않음\r\n1: True\r\n2: False",
"actions.find.wholeWordOverride": "\"전체 단어 일치\" 플래그를 재정의합니다.\r\n플래그는 미래를 위해 저장되지 않습니다.\r\n0: 아무것도 하지 않음\r\n1: True\r\n2: False",
"findMatchAction.goToMatch": "일치 항목으로 이동...",
"findMatchAction.inputPlaceHolder": "특정 일치 항목으로 이동하려면 숫자를 입력하세요(1~{0} 사이).",
"findMatchAction.inputValidationMessage": "1에서 {0} 사이의 숫자를 입력하세요",
"findNextMatchAction": "다음 찾기",
"findPreviousMatchAction": "이전 찾기",
"miFind": "찾기(&&F)",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "처음 {0}개의 결과가 강조 표시되지만 모든 찾기 작업은 전체 텍스트에 대해 수행됩니다."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "편집기 여백의 접기 컨트롤 색입니다.",
"createManualFoldRange.label": "선택 영역에서 접기 범위 만들기",
"foldAction.label": "접기",
"foldAllAction.label": "모두 접기",
"foldAllBlockComments.label": "모든 블록 코멘트를 접기",
"foldAllExcept.label": "선택한 영역을 제외한 모든 영역 접기",
"foldAllMarkerRegions.label": "모든 영역 접기",
"foldBackgroundBackground": "접힌 범위의 배경색입니다. 색은 기본 장식을 숨기지 않기 위해 불투명해서는 안 됩니다.",
"foldLevelAction.label": "수준 {0} 접기",
"foldRecursivelyAction.label": "재귀적으로 접기",
"gotoNextFold.label": "다음 접기 범위로 이동",
"gotoParentFold.label": "부모 폴딩으로 이동",
"gotoPreviousFold.label": "이전 접기 범위로 이동",
"maximum fold ranges": "폴더블 영역의 수는 최대 {0}개로 제한됩니다. 폴더블 영역 수를 늘리려면 ['폴딩 최대 영역'](command:workbench.action.openSettings?[\"editor.foldingMaximumRegions\"]) 구성 옵션을 늘리세요.",
"removeManualFoldingRanges.label": "수동 폴딩 범위 제거",
"toggleFoldAction.label": "접기 전환",
"unFoldRecursivelyAction.label": "재귀적으로 펼치기",
"unfoldAction.label": "펼치기",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "모든 영역 펼치기"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "편집기 여백의 접기 컨트롤 색입니다.",
"foldBackgroundBackground": "접힌 범위의 배경색입니다. 색은 기본 장식을 숨기지 않기 위해 불투명해서는 안 됩니다.",
"foldingCollapsedIcon": "편집기 문자 모양 여백에서 축소된 범위의 아이콘입니다.",
"foldingExpandedIcon": "편집기 문자 모양 여백에서 확장된 범위의 아이콘입니다."
"foldingExpandedIcon": "편집기 문자 모양 여백에서 확장된 범위의 아이콘입니다.",
"foldingManualCollapedIcon": "편집기 문자 모양 여백에서 수동으로 축소된 범위에 대한 아이콘입니다.",
"foldingManualExpandedIcon": "편집기 문자 모양 여백에서 수동으로 확장된 범위에 대한 아이콘입니다."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "편집기 글꼴 확대",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "로드 중...",
"stopped rendering": "성능상의 이유로 긴 줄로 인해 렌더링이 일시 중지되었습니다. `editor.stopRenderingLineAfter`를 통해 구성할 수 있습니다.",
"too many characters": "성능상의 이유로 긴 줄의 경우 토큰화를 건너뜁니다. 이 항목은 'editor.maxTokenizationLineLength'를 통해 구성할 수 있습니다."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "문제 보기"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "탭 표시 크기 변경",
"configuredTabSize": "구성된 탭 크기",
"currentTabSize": "현재 탭 크기",
"defaultTabSize": "기본 탭 크기",
"detectIndentation": "콘텐츠에서 들여쓰기 감지",
"editor.reindentlines": "줄 다시 들여쓰기",
"editor.reindentselectedlines": "선택한 줄 다시 들여쓰기",
@ -864,7 +977,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/inlayHints/browser/inlayHintsHover": {
"hint.cmd": "명령 실행",
"hint.dbl": "삽입하려면 두 번 클릭하세요.",
"hint.dbl": "삽입하려면 두 번 클릭",
"hint.def": "정의로 이동({0})",
"hint.defAndCommand": "정의({0})로 이동하여 자세히 알아보려면 마우스 오른쪽 단추를 클릭합니다.",
"links.navigate.kb.alt": "Alt+클릭",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "Cmd+클릭"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "수락",
"acceptWord": "단어 수락",
"action.inlineSuggest.accept": "인라인 추천 수락",
"action.inlineSuggest.acceptNextWord": "인라인 제안의 다음 단어 수락",
"action.inlineSuggest.alwaysShowToolbar": "항상 도구 모음 표시",
"action.inlineSuggest.hide": "인라인 제안 숨기기",
"action.inlineSuggest.showNext": "다음 인라인 제안 표시",
"action.inlineSuggest.showPrevious": "이전 인라인 제안 표시",
"action.inlineSuggest.trigger": "인라인 제안 트리거",
"action.inlineSuggest.undo": "Word 수락 취소",
"alwaysShowInlineSuggestionToolbar": "인라인 추천 도구 모음을 항상 표시할지 여부",
"canUndoInlineSuggestion": "실행 취소가 인라인 제안을 실행 취소할지 여부",
"inlineSuggestionHasIndentation": "인라인 제안이 공백으로 시작하는지 여부",
"inlineSuggestionHasIndentationLessThanTabSize": "인라인 제안이 탭에 의해 삽입되는 것보다 작은 공백으로 시작하는지 여부",
"inlineSuggestionVisible": "인라인 제안 표시 여부"
"inlineSuggestionVisible": "인라인 제안 표시 여부",
"undoAcceptWord": "단어 수락 취소"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "제안:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0}({1})",
"next": "다음",
"parameterHintsNextIcon": "다음 매개 변수 힌트 표시의 아이콘입니다.",
"parameterHintsPreviousIcon": "이전 매개 변수 힌트 표시의 아이콘입니다.",
"previous": "이전"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "다음 값으로 바꾸기",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "중복된 선택 영역",
"editor.transformToCamelcase": "Camel Case로 변환",
"editor.transformToKebabcase": "Kebab 사례로 변환",
"editor.transformToLowercase": "소문자로 변환",
"editor.transformToSnakecase": "스네이크 표기법으로 변환",
"editor.transformToTitlecase": "단어의 첫 글자를 대문자로 변환",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "명령 {0} 실행"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "읽기 전용 편집기에서는 편집할 수 없습니다.",
"messageVisible": "편집기에서 현재 인라인 메시지를 표시하는지 여부"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "마지막 선택 항목을 이전 일치 항목 찾기로 이동",
"mutlicursor.addCursorsToBottom": "맨 아래에 커서 추가",
"mutlicursor.addCursorsToTop": "맨 위에 커서 추가",
"mutlicursor.focusNextCursor": "다음 커서 포커스",
"mutlicursor.focusNextCursor.description": "다음 커서에 포커스를 맞춥니다.",
"mutlicursor.focusPreviousCursor": "이전 커서 포커스",
"mutlicursor.focusPreviousCursor.description": "이전 커서에 포커스를 맞춥니다.",
"mutlicursor.insertAbove": "위에 커서 추가",
"mutlicursor.insertAtEndOfEachLineSelected": "줄 끝에 커서 추가",
"mutlicursor.insertBelow": "아래에 커서 추가",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Peek 뷰 편집기의 거터 배경색입니다.",
"peekViewEditorMatchHighlight": "Peek 뷰 편집기의 일치 항목 강조 표시 색입니다.",
"peekViewEditorMatchHighlightBorder": "Peek 뷰 편집기의 일치 항목 강조 표시 테두리입니다.",
"peekViewEditorStickScrollBackground": "피킹 뷰 편집기의 고정 스크롤 배경색입니다.",
"peekViewResultsBackground": "Peek 뷰 결과 목록의 배경색입니다.",
"peekViewResultsFileForeground": "Peek 뷰 결과 목록에서 파일 노드의 전경색입니다.",
"peekViewResultsMatchForeground": "Peek 뷰 결과 목록에서 라인 노드의 전경색입니다.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "형식 매개 변수({0})",
"variable": "변수({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "읽기 전용 편집기에서는 편집할 수 없습니다.",
"editor.simple.readonly": "읽기 전용 입력에서는 편집할 수 없습니다."
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "'{0}'을(를) '{1}'(으)로 이름을 변경했습니다. 요약: {2}",
"enablePreview": "이름을 바꾸기 전에 변경 내용을 미리 볼 수 있는 기능 사용/사용 안 함",
"label": "'{0}'의 이름을 바꾸는 중",
"label": "'{0}'에서 '{1}'(으)로 이름을 바꾸는 중",
"no result": "결과가 없습니다.",
"quotableLabel": "{0} 이름 바꾸기",
"quotableLabel": "{1}에 {0} 이름 바꾸기",
"rename.failed": "이름 바꾸기를 통해 편집 내용을 계산하지 못했습니다.",
"rename.failedApply": "이름 바꾸기를 통해 편집 내용을 적용하지 못했습니다.",
"rename.label": "기호 이름 바꾸기",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "코드 조각 모드일 때 다음 탭 정지가 있는지 여부",
"hasPrevTabstop": "코드 조각 모드일 때 이전 탭 정지가 있는지 여부",
"inSnippetMode": "현재 편집기가 코드 조각 모드인지 여부"
"inSnippetMode": "현재 편집기가 코드 조각 모드인지 여부",
"next": "다음 자리 표시자로 이동..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "4월",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "수요일",
"WednesdayShort": "수"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "고정 스크롤(&&S)",
"mitoggleStickyScroll": "고정 스크롤 토글(&&T)",
"stickyScroll": "고정 스크롤",
"toggleStickyScroll": "고정 스크롤 토글"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "<Enter> 키를 누를 때 제안이 삽입되는지 여부",
"suggestWidgetDetailsVisible": "제안 세부 정보가 표시되는지 여부",
"suggestWidgetHasSelection": "제안에 초점을 맞추는지 여부",
"suggestWidgetMultipleSuggestions": "선택할 수 있는 여러 제안이 있는지 여부",
"suggestionCanResolve": "현재 제안에서 추가 세부 정보를 확인하도록 지원하는지 여부",
"suggestionHasInsertAndReplaceRange": "현재 제안에 삽입 및 바꾸기 동작이 있는지 여부",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "제안 위젯에서 자세한 정보의 아이콘입니다."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0}({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "배열 기호의 전경색입니다. 이러한 기호는 개요, 이동 경로 및 제안 위젯에 나타납니다.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "이 파일 ‘\r\n’에 LS(줄 구분 기호) 또는 PS(단락 구분 기호) 같은 하나 이상의 비정상적인 줄 종결자 문자가 포함되어 있습니다.{0}\r\n파일에서 제거하는 것이 좋습니다. `editor.unusualLineTerminators`를 통해 구성할 수 있습니다.",
"unusualLineTerminators.fix": "비정상적인 줄 종결자 제거",
"unusualLineTerminators.fix": "비정상적인 줄 종결자 제거(&&R)",
"unusualLineTerminators.ignore": "무시",
"unusualLineTerminators.message": "비정상적인 줄 종결자가 검색됨",
"unusualLineTerminators.title": "비정상적인 줄 종결자"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "기호 강조 표시의 개요 눈금자 표식 색입니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"overviewRulerWordHighlightStrongForeground": "쓰기 액세스 기호에 대한 개요 눈금자 표식 색이 강조 표시됩니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"overviewRulerWordHighlightTextForeground": "기호에 대한 텍스트 항목의 개요 눈금자 마커 색입니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"wordHighlight": "변수 읽기와 같은 읽기 액세스 중 기호의 배경색입니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"wordHighlight.next.label": "다음 강조 기호로 이동",
"wordHighlight.previous.label": "이전 강조 기호로 이동",
"wordHighlight.trigger.label": "기호 강조 표시 트리거",
"wordHighlightBorder": "변수 읽기와 같은 읽기 액세스 중 기호의 테두리 색입니다.",
"wordHighlightStrong": "변수에 쓰기와 같은 쓰기 액세스 중 기호의 배경색입니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"wordHighlightStrongBorder": "변수에 쓰기와 같은 쓰기 액세스 중 기호의 테두리 색입니다."
"wordHighlightStrongBorder": "변수에 쓰기와 같은 쓰기 액세스 중 기호의 테두리 색입니다.",
"wordHighlightText": "기호에 대한 텍스트 항목의 배경색입니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"wordHighlightTextBorder": "기호에 대한 텍스트 항목의 테두리 색입니다."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "다음 강조 기호로 이동",
"wordHighlight.previous.label": "이전 강조 기호로 이동",
"wordHighlight.trigger.label": "기호 강조 표시 트리거"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "단어 삭제"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "개발자",
"help": "도움말",
"preferences": "기본 설정",
"test": "테스트",
"view": "보기"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0}({1})"
"titleAndKb": "{0}({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "숨기기",
"resetThisMenu": "메뉴 다시 설정"
},
"vs/platform/actions/common/menuService": {
"hide.label": "'{0}' 숨기기"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "작업 위젯",
"customQuickFixWidget.labels": "{0}, 사용 안 함 이유: {1}",
"label": "신청하려면 {0}",
"label-preview": "적용하려면 {0}, 미리 보기를 보려면 {1}"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "선택한 작업 수락",
"codeActionMenuVisible": "작업 위젯 목록 표시 여부",
"hideCodeActionWidget.title": "작업 위젯 숨기기",
"previewSelected.title": "선택한 작업 미리 보기",
"selectNextCodeAction.title": "다음 작업 선택",
"selectPrevCodeAction.title": "이전 작업 선택"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Diff 줄 삭제됨",
"audioCues.diffLineInserted": "Diff 줄 삽입됨",
"audioCues.diffLineModified": "Diff 줄 수정됨",
"audioCues.lineHasBreakpoint.name": "줄의 중단점",
"audioCues.lineHasError.name": "줄에 대한 오류",
"audioCues.lineHasFoldedArea.name": "줄의 접힌 부분",
"audioCues.lineHasInlineSuggestion.name": "줄의 인라인 제안",
"audioCues.lineHasWarning.name": "줄에 대한 경고",
"audioCues.noInlayHints": "줄의 인레이 힌트 없음",
"audioCues.notebookCellCompleted": "Notebook 셀 완료됨",
"audioCues.notebookCellFailed": "Notebook 셀 실패",
"audioCues.onDebugBreak.name": "중단점에서 중지된 디버거",
"audioCues.taskCompleted": "완료된 작업",
"audioCues.taskFailed": "작업 실패",
"audioCues.terminalBell": "터미널 벨",
"audioCues.terminalCommandFailed": "터미널 명령 실패",
"audioCues.terminalQuickFix.name": "터미널 빠른 수정"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "'{0}'을(를) 등록할 수 없습니다. 연결된 정책 {1}이(가) 이미 {2}에 등록되어 있습니다.",
"config.property.duplicate": "'{0}'을(를) 등록할 수 없습니다. 이 속성은 이미 등록되어 있습니다.",
"config.property.empty": "빈 속성을 등록할 수 없음",
"config.property.languageDefault": "'{0}'을(를) 등록할 수 없습니다. 이는 언어별 편집기 설정을 설명하는 속성 패턴인 '\\\\[.*\\\\]$'과(와) 일치합니다. 'configurationDefaults' 기여를 사용하세요.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "운영 체제가 Linux인지 여부",
"isMac": "운영 체제가 macOS인지 여부",
"isMacNative": "브라우저 기반이 아닌 플랫폼에서 운영 체제가 macOS인지 여부",
"isMobile": "플랫폼이 모바일 웹 브라우저인지 여부",
"isWeb": "플랫폼이 웹 브라우저인지 여부",
"isWindows": "운영 체제가 Windows인지 여부"
"isWindows": "운영 체제가 Windows인지 여부",
"productQualityType": "VS 코드의 품질 유형"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "취소",
"moreFile": "...1개의 추가 파일이 표시되지 않음",
"moreFiles": "...{0}개의 추가 파일이 표시되지 않음"
"moreFiles": "...{0}개의 추가 파일이 표시되지 않음",
"okButton": "확인(&&O)",
"yesButton": "예(&&Y)"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "파일이 너무 커서 제목 없는 편집기로 열 수 없습니다. 먼저 파일을 파일 탐색기에 업로드한 후 다시 시도하세요."
},
"vs/platform/files/common/files": {
"sizeB": "{0}B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "'Alt' 키를 누를 때 스크롤 속도 승수입니다.",
"Mouse Wheel Scroll Sensitivity": "마우스 휠 스크롤 이벤트의 `deltaX` 및 `deltaY`에서 사용할 승수입니다.",
"automatic keyboard navigation setting": "목록 및 트리에서 키보드 탐색이 입력만으로 자동 트리거되는지 여부를 제어합니다. 'false'로 설정하면 'list.toggleKeyboardNavigation' 명령을 실행할 때만 키보드 탐색이 트리거되어 바로 가기 키를 할당할 수 있습니다.",
"defaultFindMatchTypeSettingKey": "워크벤치에서 목록 및 트리를 검색할 때 사용하는 일치 유형을 제어합니다.",
"defaultFindMatchTypeSettingKey.contiguous": "검색할 때 연속 일치를 사용합니다.",
"defaultFindMatchTypeSettingKey.fuzzy": "검색할 때 유사 항목 일치를 사용합니다.",
"defaultFindModeSettingKey": "워크벤치에서 목록 및 트리의 기본 찾기 모드를 제어합니다.",
"defaultFindModeSettingKey.filter": "검색할 때 요소를 필터링합니다.",
"defaultFindModeSettingKey.highlight": "검색할 때 요소를 강조 표시합니다. 추가 위아래 탐색은 강조 표시된 요소만 탐색합니다.",
"expand mode": "폴더 이름을 클릭할 때 트리 폴더가 확장되는 방법을 제어합니다. 일부 트리와 목록에서는 이 설정을 적용할 수 없는 경우 무시하도록 선택할 수 있습니다.",
"horizontalScrolling setting": "워크벤치에서 목록 및 트리의 가로 스크롤 여부를 제어합니다. 경고: 이 설정을 켜면 성능에 영향을 미칩니다.",
"keyboardNavigationSettingKey": "워크벤치의 목록 및 트리 키보드 탐색 스타일을 제어합니다. 간소화하고, 강조 표시하고, 필터링할 수 있습니다.",
"keyboardNavigationSettingKey.filter": "키보드 탐색 필터링에서는 키보드 입력과 일치하지 않는 요소를 모두 필터링하여 숨깁니다.",
"keyboardNavigationSettingKey.highlight": "키보드 탐색 강조 표시에서는 키보드 입력과 일치하는 요소를 강조 표시합니다. 이후로 탐색에서 위 및 아래로 이동하는 경우 강조 표시된 요소만 트래버스합니다.",
"keyboardNavigationSettingKey.simple": "간단한 키보드 탐색에서는 키보드 입력과 일치하는 요소에 집중합니다. 일치는 접두사에서만 수행됩니다.",
"keyboardNavigationSettingKeyDeprecated": "대신 'workbench.list.defaultFindMode' 및 'workbench.list.typeNavigationMode'를 사용하세요.",
"list smoothScrolling setting": "목록과 트리에 부드러운 화면 이동 기능이 있는지를 제어합니다.",
"list.scrollByPage": "스크롤 막대 스크롤 페이지의 페이지별 클릭 여부를 제어합니다.",
"multiSelectModifier": "마우스로 트리와 목록의 항목을 다중 선택에 추가할 때 사용할 한정자입니다(예를 들어 탐색기에서 편집기와 SCM 보기를 여는 경우). '옆에서 열기' 마우스 제스처(지원되는 경우)는 다중 선택 한정자와 충돌하지 않도록 조정됩니다.",
"multiSelectModifier.alt": "Windows와 Linux의 'Alt'를 macOS의 'Option'으로 매핑합니다.",
"multiSelectModifier.ctrlCmd": "Windows와 Linux의 'Control'을 macOS의 'Command'로 매핑합니다.",
"openModeModifier": "트리와 목록에서 마우스를 사용하여 항목을 여는 방법을 제어합니다(지원되는 경우). 일부 트리와 목록에서는 이 설정을 적용할 수 없는 경우 무시하도록 선택할 수 있습니다.",
"render tree indent guides": "트리에서 들여쓰기 가이드를 렌더링할지 여부를 제어합니다.",
"tree indent setting": "트리 들여쓰기를 픽셀 단위로 제어합니다.",
"typeNavigationMode": "워크벤치의 목록 및 트리에서 형식 탐색이 작동하는 방식을 제어합니다. 'trigger'로 설정 시 'list.triggerTypeNavigation' 명령이 실행되면 형식 탐색이 시작됩니다.",
"workbenchConfigurationTitle": "워크벤치"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "경고"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "명령 '{0}'에서 오류({1})가 발생했습니다.",
"canNotRun": "'{0}' 명령에서 오류가 발생했습니다.",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "일반적으로 사용됨",
"morecCommands": "기타 명령",
"recentlyUsed": "최근에 사용한 항목"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "편집기 명령",
"globalCommands": "전역 명령",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "사용자 지정",
"inputModeEntry": "입력을 확인하려면 'Enter' 키를 누르고, 취소하려면 'Esc' 키를 누르세요.",
"inputModeEntryDescription": "{0}(확인하려면 'Enter' 키를 누르고, 취소하려면 'Escape' 키를 누름)",
"ok": "확인",
"quickInput.back": "뒤로",
"quickInput.backWithKeybinding": "뒤로({0})",
"quickInput.checkAll": "모든 확인란 선택/해제",
"quickInput.countSelected": "{0} 선택됨",
"quickInput.steps": "{0} / {1}",
"quickInput.visibleCount": "{0}개 결과",
"quickInputBox.ariaLabel": "결과의 범위를 축소하려면 입력하세요."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "빠른 입력"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "'{0}' 명령을 실행하려면 클릭"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "더 뚜렷이 대비되도록 요소를 다른 요소와 구분하는 활성 요소 주위의 추가 테두리입니다.",
"activeLinkForeground": "활성 링크의 색입니다.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "이동 경로 항목의 배경색입니다.",
"breadcrumbsFocusForeground": "포커스가 있는 이동 경로 항목의 색입니다.",
"breadcrumbsSelectedBackground": "이동 경로 항목 선택기의 배경색입니다.",
"breadcrumbsSelectedForegound": "선택한 이동 경로 항목의 색입니다.",
"breadcrumbsSelectedForeground": "선택한 이동 경로 항목의 색입니다.",
"buttonBackground": "단추 배경색입니다.",
"buttonBorder": "버튼 테두리 색입니다.",
"buttonForeground": "단추 기본 전경색입니다.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "보조 단추 배경색입니다.",
"buttonSecondaryForeground": "보조 단추 전경색입니다.",
"buttonSecondaryHoverBackground": "마우스로 가리킬 때 보조 단추 배경색입니다.",
"buttonSeparator": "단추 구분 기호 색입니다.",
"chartsBlue": "차트 시각화에 사용되는 파란색입니다.",
"chartsForeground": "차트에 사용된 전경색입니다.",
"chartsGreen": "차트 시각화에 사용되는 녹색입니다.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "확인란 위젯의 배경색입니다.",
"checkbox.border": "확인란 위젯의 테두리 색입니다.",
"checkbox.foreground": "확인란 위젯의 전경색입니다.",
"checkbox.select.background": "확인란 위젯이 포함된 요소가 선택된 경우의 확인란 위젯 배경색입니다.",
"checkbox.select.border": "확인란 위젯이 포함된 요소가 선택된 경우의 확인란 위젯 테두리 색입니다.",
"contrastBorder": "더 뚜렷이 대비되도록 요소를 다른 요소와 구분하는 요소 주위의 추가 테두리입니다.",
"descriptionForeground": "레이블과 같이 추가 정보를 제공하는 설명 텍스트의 전경색입니다.",
"diffDiagonalFill": "diff 편집기의 대각선 채우기 색입니다. 대각선 채우기는 diff 나란히 보기에서 사용됩니다.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "줄이 제거된 여백의 배경색입니다.",
"diffEditorRemovedLines": "제거된 줄의 배경색입니다. 색상은 기본 장식을 숨기지 않도록 불투명하지 않아야 합니다.",
"diffEditorRemovedOutline": "제거된 텍스트의 윤곽선 색입니다.",
"disabledForeground": "비활성화된 요소의 전체 전경입니다. 이 색은 구성 요소에서 재정의하지 않는 경우에만 사용됩니다.",
"dropdownBackground": "드롭다운 배경입니다.",
"dropdownBorder": "드롭다운 테두리입니다.",
"dropdownForeground": "드롭다운 전경입니다.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "고대비를 위한 선택 텍스트의 색입니다.",
"editorSelectionHighlight": "선택 영역과 동일한 콘텐츠가 있는 영역의 색입니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"editorSelectionHighlightBorder": "선택 영역과 동일한 콘텐츠가 있는 영역의 테두리 색입니다.",
"editorStickyScrollBackground": "편집기의 고정 스크롤 배경색",
"editorStickyScrollHoverBackground": "편집기의 가리킨 항목 배경색에 고정 스크롤",
"editorWarning.background": "편집기에서 경고 텍스트의 배경색입니다. 기본 장식을 숨기지 않도록 색은 불투명하지 않아야 합니다.",
"editorWarning.foreground": "편집기 내 경고 표시선의 전경색입니다.",
"editorWidgetBackground": "찾기/바꾸기 같은 편집기 위젯의 배경색입니다.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "목록 및 트리에서 형식 필터 위젯의 배경색입니다.",
"listFilterWidgetNoMatchesOutline": "일치하는 항목이 없을 때 목록 및 트리에서 표시되는 형식 필터 위젯의 윤곽선 색입니다.",
"listFilterWidgetOutline": "목록 및 트리에서 형식 필터 위젯의 윤곽선 색입니다.",
"listFilterWidgetShadow": "목록 및 트리에 있는 유형 필터 위젯의 그림자 색상입니다.",
"listFocusAndSelectionOutline": "목록/트리가 활성화되고 선택되었을 때 초점이 맞춰진 항목의 목록/트리 윤곽선 색상입니다. 활성 목록/트리에는 키보드 포커스가 있고 비활성에는 그렇지 않습니다.",
"listFocusBackground": "목록/트리가 활성 상태인 경우 포커스가 있는 항목의 목록/트리 배경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.",
"listFocusForeground": "목록/트리가 활성 상태인 경우 포커스가 있는 항목의 목록/트리 전경색입니다. 목록/트리가 활성 상태이면 키보드 포커스를 가지며, 비활성 상태이면 포커스가 없습니다.",
"listFocusHighlightForeground": "목록/트리 내에서 검색할 때 일치 항목의 목록/트리 전경색이 능동적으로 포커스가 있는 항목을 강조 표시합니다.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "작업 위에 마우스를 놓았을 때 도구 모음 배경",
"toolbarHoverBackground": "마우스를 사용하여 작업 위로 마우스를 가져가는 경우 도구 모음 배경",
"toolbarHoverOutline": "마우스를 사용하여 작업 위로 마우스를 가져가는 경우 도구 모음 윤곽선",
"treeInactiveIndentGuidesStroke": "활성 상태가 아닌 들여쓰기 안내선의 트리 스트로크 색입니다.",
"treeIndentGuidesStroke": "들여쓰기 가이드의 트리 스트로크 색입니다.",
"warningBorder": "편집기에서 경고 상자의 테두리 색입니다.",
"widgetBorder": "편집기 내에서 찾기/바꾸기와 같은 위젯의 테두리 색입니다.",
"widgetShadow": "편집기 내에서 찾기/바꾸기 같은 위젯의 그림자 색입니다."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "위젯에서 닫기 작업의 아이콘입니다."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "취소",
"cannotResourceRedoDueToInProgressUndoRedo": "실행 취소 또는 다시 실행 작업이 이미 실행 중이므로 '{0}'을(를) 다시 실행할 수 없습니다.",
"cannotResourceUndoDueToInProgressUndoRedo": "실행 취소 또는 다시 실행 작업이 이미 실행 중이므로 '{0}'을(를) 실행 취소할 수 없습니다.",
"cannotWorkspaceRedo": "모든 파일에서 '{0}'을(를) 다시 실행할 수 없습니다. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "{1}에서 실행 취소 또는 다시 실행 작업이 이미 실행 중이므로 모든 파일에서 '{0}'을(를) 실행 취소할 수 없습니다.",
"confirmDifferentSource": "'{0}'을(를) 실행 취소하시겠습니까?",
"confirmDifferentSource.no": "아니요",
"confirmDifferentSource.yes": "예",
"confirmDifferentSource.yes": "예(&&Y)",
"confirmWorkspace": "모든 파일에서 '{0}'을(를) 실행 취소하시겠습니까?",
"externalRemoval": "{0} 파일이 닫히고 디스크에서 수정되었습니다.",
"noParallelUniverses": "{0} 파일은 호환되지 않는 방식으로 수정되었습니다.",
"nok": "이 파일 실행 취소",
"ok": "{0}개 파일에서 실행 취소"
"nok": "이 파일 실행 취소(&&F)",
"ok": "파일 {0}개에서 실행 취소(&&U)"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "코드 작업 영역"

396
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/pl.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Więcej akcji..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Zamknij okno dialogowe",
"dialogErrorMessage": "Błąd",
"dialogInfoMessage": "Informacje",
"dialogPendingMessage": "W toku",
"dialogWarningMessage": "Ostrzeżenie",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Więcej akcji..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "wejście"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Uwzględnij wielkość liter",
"regexDescription": "Użyj wyrażenia regularnego",
"wordsDescription": "Uwzględnij całe wyrazy"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "wejście",
"label.preserveCaseToggle": "Zachowaj wielkość liter"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Niepowiązany"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Pole opcji"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Więcej akcji..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Wyczyść",
"disable filter on type": "Wyłącz filtrowanie według typu",
"empty": "Nie znaleziono elementów",
"enable filter on type": "Włącz filtrowanie według typu",
"found": "Dopasowano {0} z {1} elementów"
"close": "Zamknij",
"filter": "Filtr",
"fuzzySearch": "Dopasowanie rozmyte",
"not found": "Nie znaleziono elementów.",
"type to filter": "Wpisz, aby filtrować",
"type to search": "Wpisz, aby wyszukać"
},
"vs/base/common/actions": {
"submenu.empty": "(puste)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Niestandardowe",
"inputModeEntry": "Naciśnij klawisz „Enter”, aby potwierdzić dane wejściowe, lub klawisz „Escape”, aby anulować",
"inputModeEntryDescription": "{0} (naciśnij klawisz „Enter”, aby potwierdzić, lub klawisz „Escape”, aby anulować)",
"ok": "OK",
"quickInput.back": "Wstecz",
"quickInput.backWithKeybinding": "Wstecz ({0})",
"quickInput.countSelected": "Liczba wybranych: {0}",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "Liczba wyników: {0}",
"quickInputBox.ariaLabel": "Wpisz, aby zawęzić wyniki."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Szybkie wejście"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "Edytor nie jest w tej chwili dostępny. Naciśnij {0}, aby wyświetlić opcje.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Cofnij"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "Liczba kursorów została ograniczona do {0}."
"cursors.maximum": "Liczba kursorów została ograniczona do {0}. Rozważ użycie funkcji [wyszukaj i zamień](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) w celu wprowadzenia większych zmian lub zwiększenia ustawienia limitu wielu kursorów edytora.",
"goToSetting": "Zwiększ limit wielu kursorów"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " użyj klawiszy Shift + F7, aby nawigować po zmianach",
"diff.tooLarge": "Nie można porównać plików, ponieważ jeden plik jest zbyt duży.",
"diffInsertIcon": "Dekoracje wierszy dla wstawień w edytorze różnic.",
"diffRemoveIcon": "Dekoracje wierszy dla usunięć w edytorze różnic."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Określa, czy w edytorze są wyświetlane wskaźniki CodeLens.",
"detectIndentation": "Określa, czy ustawienia „#editor.tabSize#” i „#editor.insertSpaces#” będą wykrywane automatycznie na podstawie zawartości pliku po otwarciu pliku.",
"detectIndentation": "Określa, czy {0} i {1} będą automatycznie wykrywane po otwarciu pliku na podstawie zawartości pliku.",
"diffAlgorithm.experimental": "Używa eksperymentalnego algorytmu porównywania.",
"diffAlgorithm.smart": "Używa domyślnego algorytmu porównywania.",
"editor.experimental.asyncTokenization": "Określa, czy tokenizacja ma być wykonywana asynchronicznie w internetowym procesie roboczym.",
"editorConfigurationTitle": "Edytor",
"ignoreTrimWhitespace": "Po włączeniu tej opcji edytor różnic ignoruje zmiany w wiodącym lub końcowym białym znaku.",
"insertSpaces": "Wstaw spacje po naciśnięciu klawisza „Tab”. To ustawienie jest przesłaniane na podstawie zawartości pliku, gdy opcja „#editor.detectIndentation#” jest włączona.",
"indentSize": "Liczba spacji używanych w przypadku wcięcia lub „tabSize” na potrzeby użycia wartości z „#editor.tabSize#”. To ustawienie jest zastępowane na podstawie zawartości pliku, gdy „#editor.detectIndentation#” jest włączony.",
"insertSpaces": "Wstaw spacje po naciśnięciu klawisza „Tab”. To ustawienie jest przesłaniane na podstawie zawartości pliku, gdy opcja {0} jest włączona.",
"largeFileOptimizations": "Specjalna obsługa dużych plików w celu wyłączenia pewnych funkcji intensywnie korzystających z pamięci.",
"maxComputationTime": "Limit czasu (w milisekundach), po upływie którego obliczanie różnic jest anulowane. Użyj wartości 0, aby nie ustawiać limitu czasu.",
"maxFileSize": "Maksymalny rozmiar pliku w MB, dla którego mają być obliczane różnice. W przypadku braku limitu użyj wartości 0.",
"maxTokenizationLineLength": "Wiersze powyżej tej długości nie będą tokenizowane ze względu na wydajność",
"renderIndicators": "Określa, czy edytor różnic pokazuje wskaźniki +/- dla dodanych/usuniętych zmian.",
"renderMarginRevertIcon": "Gdy ta opcja jest włączona, edytor różnic pokazuje strzałki na marginesie symboli, aby przywrócić zmiany.",
"schema.brackets": "Definiuje symbole nawiasów, które zwiększają lub zmniejszają wcięcie.",
"schema.closeBracket": "Znak nawiasu zamykającego lub sekwencja ciągu.",
"schema.colorizedBracketPairs": "Definiuje pary nawiasów, które są koloryzowane według ich poziomu zagnieżdżenia, jeśli opcja kolorowania par nawiasów jest włączona.",
@ -139,15 +160,15 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.false": "Wyróżnianie semantyczne wyłączone dla wszystkich motywów kolorów.",
"semanticHighlighting.true": "Wyróżnianie semantyczne włączone dla wszystkich motywów kolorów.",
"sideBySide": "Określa, czy edytor różnic pokazuje porównanie obok siebie, czy w trybie śródwierszowym.",
"stablePeek": "Zachowuj otwarte edytory wglądu nawet po dwukrotnym kliknięciu ich zawartości lub naciśnięciu klawisza „Escape”.",
"tabSize": "Liczba spacji, której równy jest tabulator. To ustawienie jest przesłaniane na podstawie zawartości pliku, gdy jest włączona opcja „#editor.detectIndentation#”.",
"stablePeek": "Zachowuj otwarte edytory wglądu nawet po dwukrotnym kliknięciu ich zawartości lub naciśnięciu klawisza `Escape`.",
"tabSize": "Liczba spacji, której równy jest tabulator. To ustawienie jest przesłaniane na podstawie zawartości pliku, gdy jest włączona opcja {0}.",
"trimAutoWhitespace": "Usuń automatycznie wstawiony końcowy znak odstępu.",
"wordBasedSuggestions": "Określa, czy uzupełnienia powinny być obliczane na podstawie słów w dokumencie.",
"wordBasedSuggestionsMode": "Steruje tym, jakie dokumenty są używane do obliczania ukończenia na podstawie wyrazów.",
"wordBasedSuggestionsMode.allDocuments": "Sugeruj wyrazy ze wszystkich otwartych dokumentów.",
"wordBasedSuggestionsMode.currentDocument": "Sugeruj tylko wyrazy z aktywnego dokumentu.",
"wordBasedSuggestionsMode.matchingDocuments": "Sugeruj wyrazy ze wszystkich otwartych dokumentów w tym samym języku.",
"wordWrap.inherit": "Wiersze będą zawijane zgodnie z ustawieniem „#editor.wordWrap#”.",
"wordWrap.inherit": "Wiersze będą zawijane zgodnie z ustawieniem {0}.",
"wordWrap.off": "Wiersze nigdy nie będą zawijane.",
"wordWrap.on": "Wiersze będą zawijane przy szerokości okienka ekranu."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Określa, czy sugestie powinny być akceptowane po naciśnięciu klawisza „Enter”, tak jak po naciśnięciu klawisza „Tab”. Pomaga uniknąć niejednoznaczności między wstawianiem nowych wierszy i akceptowaniem sugestii.",
"acceptSuggestionOnEnterSmart": "Akceptuj sugestię za pomocą klawisza „Enter” tylko wtedy, gdy wprowadza ona zmianę tekstową.",
"accessibilityPageSize": "Kontroluje liczbę wierszy w edytorze, które mogą być odczytywane jednocześnie przez czytnik zawartości ekranu. Po wykryciu czytnika zawartości ekranu automatycznie ustawiamy wartość domyślną na 500. Ostrzeżenie: ma to wpływ na wydajność w przypadku wartości większych niż wartość domyślna.",
"accessibilitySupport": "Określa, czy edytor powinien zostać uruchomiony w trybie zoptymalizowanym dla czytników ekranowych. Włączenie spowoduje wyłączenie zawijania wyrazów.",
"accessibilitySupport.auto": "Edytor będzie używać interfejsów API platformy do wykrywania, kiedy czytnik zawartości ekranu jest podłączony.",
"accessibilitySupport.off": "Edytor nie będzie nigdy optymalizowany pod kątem użycia z czytnikiem zawartości ekranu.",
"accessibilitySupport.on": "Edytor zostanie trwale zoptymalizowany pod kątem użycia z czytnikiem ekranu. Zawijanie wyrazów zostanie wyłączone.",
"accessibilitySupport": "Określa, czy interfejs użytkownika powinien działać w trybie, w którym jest zoptymalizowany pod kątem czytników zawartości ekranu.",
"accessibilitySupport.auto": "Wykrywanie, kiedy czytnik zawartości ekranu jest dołączony, za pomocą interfejsów API platformy",
"accessibilitySupport.off": "Załóżmy, że czytnik zawartości ekranu nie jest dołączony",
"accessibilitySupport.on": "Optymalizowanie pod kątem użycia za pomocą czytnika zawartości ekranu",
"alternativeDeclarationCommand": "Alternatywny identyfikator polecenia, które jest wykonywane, gdy wynikiem akcji „Przejdź do deklaracji” jest bieżąca lokalizacja.",
"alternativeDefinitionCommand": "Alternatywny identyfikator polecenia, które jest wykonywane, gdy wynikiem akcji „Przejdź do definicji” jest bieżąca lokalizacja.",
"alternativeImplementationCommand": "Alternatywny identyfikator polecenia, które jest wykonywane, gdy wynikiem akcji „Przejdź do implementacji” jest bieżąca lokalizacja.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Określa, czy edytor ma automatycznie zamykać cudzysłowy po dodaniu przez użytkownika cudzysłowu otwierającego.",
"autoIndent": "Określa, czy edytor powinien automatycznie dostosowywać wcięcie, gdy użytkownik wpisuje, wkleja, przenosi lub wcina wiersze.",
"autoSurround": "Określa, czy edytor ma automatycznie otaczać zaznaczenia podczas wpisywania cudzysłowów lub nawiasów.",
"bracketPairColorization.enabled": "Określa, czy kolorowanie par nawiasów jest włączone. Użyj ustawień „workbench.colorCustomizations“, aby zastąpić kolory wyróżnienia nawiasu.",
"bracketPairColorization.enabled": "Określa, czy kolorowanie par nawiasów jest włączone. Użyj {0}, aby zastąpić kolory wyróżnienia nawiasów.",
"bracketPairColorization.independentColorPoolPerBracketType": "Określa, czy każdy typ nawiasu ma własną niezależną pulę kolorów.",
"codeActions": "Włącza żarówkę akcji kodu w edytorze.",
"codeLens": "Określa, czy w edytorze są wyświetlane wskaźniki CodeLens.",
"codeLensFontFamily": "Określa rodziną czcionek dla funkcji CodeLens.",
"codeLensFontSize": "Określa rozmiar czcionki (w pikselach) dla funkcji CodeLens. W przypadku wartości „0” używane jest 90% wartości „#editor.fontSize#”.",
"codeLensFontSize": "Określa rozmiar czcionki (w pikselach) dla funkcji CodeLens. Jeśli wartość jest ustawiona na 0, używane jest 90% wartości „#editor.fontSize#”.",
"colorDecorators": "Określa, czy edytor ma renderować wbudowane dekoratory kolorów i selektor kolorów.",
"colorDecoratorsLimit": "Określa maksymalną liczbą dekoratorów kolorów, które mogą być jednocześnie renderowane w edytorze.",
"columnSelection": "Zaznaczenie za pomocą myszy i klawiszy powoduje zaznaczenie kolumny.",
"comments.ignoreEmptyLines": "Określa, czy puste wiersze mają być ignorowane z akcjami przełącz, dodaj lub usuń dla komentarzy wierszy.",
"comments.insertSpace": "Określa, czy podczas komentowania jest wstawiany znak spacji.",
"copyWithSyntaxHighlighting": "Określa, czy wyróżnianie składni ma być kopiowane do schowka.",
"cursorBlinking": "Kontroluje styl animacji kursora.",
"cursorSmoothCaretAnimation": "Określa, czy ma być włączona płynna animacja karetki.",
"cursorSmoothCaretAnimation.explicit": "Płynna animacja daszka jest włączona tylko wtedy, gdy użytkownik przesuwa kursor za pomocą jawnego gestu.",
"cursorSmoothCaretAnimation.off": "Płynna animacja daszka jest wyłączona.",
"cursorSmoothCaretAnimation.on": "Płynna animacja daszka jest zawsze włączona.",
"cursorStyle": "Steruje stylem kursora.",
"cursorSurroundingLines": "Określa minimalną liczbę widocznych wiodących i końcowych wierszy otaczających kursor. W niektórych edytorach opcja ta nazywana jest „scrollOff” lub „scrollOffset”.",
"cursorSurroundingLines": "Określa minimalną liczbę widocznych wierszy wiodących (minimum 0) i wierszy końcowych (minimum 1) otaczających kursor. W niektórych edytorach opcja ta nazywana jest „scrollOff” lub „scrollOffset”.",
"cursorSurroundingLinesStyle": "Określa, kiedy powinno być wymuszane ustawienie „cursorSurroundingLines”.",
"cursorSurroundingLinesStyle.all": "element „cursorSurroundingLines” jest wymuszany zawsze.",
"cursorSurroundingLinesStyle.default": "element „cursorSurroundingLines” jest wymuszany tylko wtedy, gdy jest wyzwalany za pomocą klawiatury lub interfejsu API.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Określa, czy gest myszy Przejdź do definicji zawsze powoduje otwarcie widżetu wglądu.",
"deprecated": "To ustawienie jest przestarzałe, zamiast tego użyj oddzielnych ustawień, takich jak „editor.suggest.showKeywords” lub „editor.suggest.showSnippets”.",
"dragAndDrop": "Określa, czy edytor powinien zezwalać na przenoszenie zaznaczeń za pomocą przeciągania i upuszczania.",
"dropIntoEditor.enabled": "Określa, czy można przeciągać i upuszczać plik do edytora, przytrzymując naciśnięty klawisz Shift (zamiast otwierać plik w edytorze).",
"editor.autoClosingBrackets.beforeWhitespace": "Automatycznie zamykaj nawiasy tylko wtedy, gdy kursor znajduje się po lewej stronie białego znaku.",
"editor.autoClosingBrackets.languageDefined": "Użyj konfiguracji języka, aby określić, kiedy automatycznie zamykać nawiasy.",
"editor.autoClosingDelete.auto": "Usuń sąsiadujące zamykające cudzysłowy lub nawiasy kwadratowe tylko wtedy, gdy zostały wstawione automatycznie.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Włącza prowadnice poziome jako dodatek do prowadnic par nawiasów pionowych.",
"editor.guides.highlightActiveBracketPair": "Określa, czy edytor powinien wyróżniać aktywną parę nawiasów.",
"editor.guides.highlightActiveIndentation": "Określa, czy edytor ma wyróżniać prowadnicę aktywnego wcięcia.",
"editor.guides.highlightActiveIndentation.always": "Wyróżnia aktywną prowadnicę wcięcia, nawet jeśli są wyróżnione prowadnice nawiasów.",
"editor.guides.highlightActiveIndentation.false": "Nie wyróżniaj aktywnej prowadnicy wcięcia.",
"editor.guides.highlightActiveIndentation.true": "Wyróżnia aktywną prowadnicę wcięcia.",
"editor.guides.indentation": "Określa, czy edytor ma renderować prowadnice wcięcia.",
"editor.inlayHints.off": "Wskazówki śródwierszowe są wyłączone",
"editor.inlayHints.offUnlessPressed": "Wskazówki śródwierszowe są domyślnie ukryte i są wyświetlane podczas przytrzymywania klawiszy {0}",
"editor.inlayHints.on": "Wskazówki śródwierszowe są włączone",
"editor.inlayHints.onUnlessPressed": "Wskazówki śródwierszowe są wyświetlane domyślnie i ukrywane podczas przytrzymywania klawiszy {0}",
"editor.stickyScroll": "Pokazuje zagnieżdżone bieżące zakresy podczas przewijania w górnej części edytora.",
"editor.stickyScroll.": "Definiuje maksymalną liczbę linii przyklejonych do pokazania.",
"editor.suggest.matchOnWordStartOnly": "Po włączeniu filtrowania funkcji IntelliSense pierwszy znak musi być zgodny na początku wyrazu, np. „c” w „Console” lub „WebContext”, ale _nie_ w „description”. Po wyłączeniu funkcja IntelliSense będzie wyświetlać więcej wyników, ale nadal sortuje je według jakości dopasowania.",
"editor.suggest.showClasss": "W przypadku włączenia tej opcji funkcja IntelliSense wyświetla sugestie „class”.",
"editor.suggest.showColors": "W przypadku włączenia tej opcji funkcja IntelliSense wyświetla sugestie „color”.",
"editor.suggest.showConstants": "W przypadku włączenia tej opcji funkcja IntelliSense wyświetla sugestie „constant”.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "W przypadku włączenia tej opcji funkcja IntelliSense wyświetla sugestie „variable”.",
"editorViewAccessibleLabel": "Zawartość edytora",
"emptySelectionClipboard": "Określa, czy kopiowanie bez zaznaczenia powoduje skopiowanie bieżącego wiersza.",
"experimentalWhitespaceRendering": "Określa, czy białe znaki są renderowane przy użyciu nowej, eksperymentalnej metody.",
"experimentalWhitespaceRendering.font": "Użyj nowej metody renderowania ze znakami czcionki.",
"experimentalWhitespaceRendering.off": "Użyj stabilnej metody renderowania.",
"experimentalWhitespaceRendering.svg": "Użyj nowej metody renderowania z funkcjami SVGS.",
"fastScrollSensitivity": "Mnożnik szybkości przewijania podczas naciskania klawisza „Alt”.",
"find.addExtraSpaceOnTop": "Określa, czy widżet Znajdź ma dodawać dodatkowe wiersze u góry edytora. Jeśli ta opcja ma wartość true, można przewijać poza pierwszy wiersz, gdy widżet Znajdź jest widoczny.",
"find.autoFindInSelection": "Steruje warunkiem automatycznego włączania znajdowania w zaznaczeniu.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Włącza/wyłącza ligatury czcionek (funkcje czcionek „calt” i „liga”). Zmień to na ciąg, aby dokładnie sterować właściwością CSS „font-feature-settings”.",
"fontLigaturesGeneral": "Konfiguruje ligatury czcionek lub funkcje czcionek. Może być wartością logiczną umożliwiającą włączenie/wyłączenie ligatur albo ciągiem określającym wartość właściwości CSS „font-feature-settings”.",
"fontSize": "Określa rozmiar czcionki w pikselach.",
"fontVariationSettings": "Jawna właściwość CSS „font-variation-settings”. Zamiast niej można przekazać wartość logiczną, jeśli jest potrzebne tylko przetłumaczenie właściwości z „font-weight” na „font-variation-settings”.",
"fontVariations": "Włącza/wyłącza tłumaczenie właściwości z „font-weight” na „font-variation-settings”. Zmień tę wartość na ciąg, aby uzyskać precyzyjną kontrolę nad właściwością CSS „font-variation-settings”.",
"fontVariationsGeneral": "Konfiguruje odmiany czcionek. Może to być wartość logiczna umożliwiająca włączenie/wyłączenie tłumaczenia właściwości z „font-weight” na „font-variation-settings” lub ciąg dla wartości właściwości CSS „font-variation-settings”.",
"fontWeight": "Steruje grubością czcionki. Akceptuje słowa kluczowe „normal” i „bold” lub liczby z zakresu od 1 do 1000.",
"fontWeightErrorMessage": "Dozwolone są tylko słowa kluczowe „normal” i „bold” lub liczby z zakresu od 1 do 1000.",
"formatOnPaste": "Określa, czy edytor ma automatycznie formatować wklejaną zawartość. Program formatujący musi być dostępny i powinien mieć możliwość formatowania zakresu w dokumencie.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Określa, czy aktywowanie ma być pokazywane.",
"hover.sticky": "Określa, czy aktywowanie powinno pozostać widoczne, gdy wskaźnik myszy zostanie nad nim przesunięty.",
"inlayHints.enable": "Włącza podpowiedzi śródwierszowe w edytorze.",
"inlayHints.fontFamily": "Kontroluje rodzinę czcionek w podpowiedziach dotyczących wkładek w edytorze. Po ustawieniu wartości pustej jest używany plik \"#editor.fontSize#\".",
"inlayHints.fontSize": "Określa rozmiar czcionki dla wskazówek śródwierszowych w edytorze. Wartość domyślna wynosząca 90% wartości `#editor.fontSize#` jest używana, gdy skonfigurowana wartość jest mniejsza niż `5` lub większa niż rozmiar czcionki edytora.",
"inlayHints.fontFamily": "Określa rodzinę czcionek dla wskazówek śródwierszowych w edytorze. Po ustawieniu pustej wartości używana jest {0}.",
"inlayHints.fontSize": "Określa rozmiar czcionki dla wskazówek śródwierszowych w edytorze. Domyślnie jest używana {0}, gdy skonfigurowana wartość jest mniejsza od {1} lub większa od rozmiaru czcionki edytora.",
"inlayHints.padding": "Włącza wypełnienie wokół wskazówek dotyczących nakładki w edytorze.",
"inline": "Szybkie sugestie są wyświetlane jako tekst widmo",
"inlineSuggest.enabled": "Określa, czy automatycznie wyświetlać wbudowane sugestie w edytorze.",
"inlineSuggest.showToolbar": "Określa, kiedy ma być wyświetlany wbudowany pasek narzędzi sugestii.",
"inlineSuggest.showToolbar.always": "Pokaż wbudowany pasek narzędzi sugestii za każdym razem, gdy jest wyświetlana wbudowana sugestia.",
"inlineSuggest.showToolbar.onHover": "Pokaż wbudowany pasek narzędzi sugestii po umieszczeniu wskaźnika myszy na wbudowanej sugestii.",
"letterSpacing": "Określa odstępy liter w pikselach.",
"lineHeight": "Kontroluje wysokość linii. \r\n — użyj wartości 0, aby automatycznie obliczyć wysokość linii na podstawie rozmiaru czcionki.\r\n — wartości w przedziale od 0 do 8 będą używane jako mnożnik z rozmiarem czcionki.\r\n — wartości większe lub równe 8 będą używane jako wartości rzeczywiste.",
"lineNumbers": "Steruje wyświetlaniem numerów wierszy.",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "Określa, czy w edytorze jest włączone edytowanie połączone. Zależnie od języka, powiązane symbole (np. tagi HTML) są aktualizowane podczas edytowania.",
"links": "Określa, czy edytor powinien wykrywać linki i umożliwiać ich kliknięcie.",
"matchBrackets": "Wyróżnij pasujące nawiasy.",
"minimap.autohide": "Określa, czy minimapa jest automatycznie chowana.",
"minimap.enabled": "Określa, czy minimapa jest wyświetlana.",
"minimap.maxColumn": "Ogranicz szerokość minimapy, aby renderować co najwyżej określoną liczbę kolumn.",
"minimap.renderCharacters": "Renderowanie rzeczywistych znaków w wierszu w przeciwieństwie do bloków koloru.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "Minimapa ma taki sam rozmiar jak zawartość edytora (i może być przewijana).",
"mouseWheelScrollSensitivity": "Mnożnik, który ma być używany w elementach „deltaX” i „deltaY” zdarzeń przewijania kółka myszy.",
"mouseWheelZoom": "Powiększ czcionkę edytora, gdy jest używane kółko myszy i przytrzymywany klawisz „Ctrl”.",
"multiCursorLimit": "Kontroluje maksymalną liczbę kursorów, które mogą znajdować się jednocześnie w aktywnym edytorze.",
"multiCursorMergeOverlapping": "Scal wiele kursorów, gdy nakładają się na siebie.",
"multiCursorModifier": "The modifier to be used to add multiple cursors with the mouse. The Go to Definition and Open Link mouse gestures will adapt such that they do not conflict with the multicursor modifier. [Read more](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "Modyfikator używany do dodawania wielu kursorów za pomocą myszy. Gesty myszy Przejdź do definicji i Otwórz link zostaną dostosowane w taki sposób, aby nie powodować konfliktu z [multicursor modifier](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier.alt": "Mapuje na klawisz „Alt” w systemach Windows i Linux oraz na klawisz „Option” w systemie macOS.",
"multiCursorModifier.ctrlCmd": "Mapuje na klawisz „Control” w systemach Windows i Linux oraz na klawisz „Command” w systemie macOS.",
"multiCursorPaste": "Steruje wklejaniem, gdy liczba wierszy wklejanego tekstu odpowiada liczbie kursora.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Określa, czy w widżecie wglądu przenieść fokus do wbudowanego edytora, czy do drzewa.",
"peekWidgetDefaultFocus.editor": "Przenieś fokus do edytora podczas otwierania wglądu",
"peekWidgetDefaultFocus.tree": "Przenieś fokus do drzewa podczas otwierania wglądu",
"quickSuggestions": "Określa, czy sugestie powinny być automatycznie wyświetlane podczas wpisywania.",
"quickSuggestions": "Określa, czy sugestie powinny być automatycznie wyświetlane podczas pisania. Można to określać wpisywaniem w komentarzach, ciągach i innym kodzie. Szybką sugestię można skonfigurować tak, aby była wyświetlana jako tekst zduplikowany lub za pomocą widżetu sugestii. Należy również pamiętać o ustawieniu „{0}”, które określa, czy sugestie są wyzwalane przez znaki specjalne.",
"quickSuggestions.comments": "Włącz szybkie sugestie wewnątrz komentarzy.",
"quickSuggestions.other": "Włącz szybkie sugestie poza ciągami i komentarzami.",
"quickSuggestions.strings": "Włącz szybkie sugestie wewnątrz ciągów.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Określa, kiedy są wyświetlane kontrolki składania w obszarze odstępu.",
"showFoldingControls.always": "Zawsze pokazuj kontrolki składania.",
"showFoldingControls.mouseover": "Pokaż kontrolki składania tylko wtedy, gdy wskaźnik myszy znajduje się nad odstępem.",
"showFoldingControls.never": "Nigdy nie pokazuj kontrolek składania i zmniejsz rozmiar odstępu.",
"showUnused": "Steruje zanikaniem nieużywanego kodu.",
"smoothScrolling": "Określa, czy edytor będzie przewijany przy użyciu animacji.",
"snippetSuggestions": "Określa, czy fragmenty są pokazywane z innymi sugestiami, i jak są sortowane.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Emuluj zachowanie zaznaczeń znaków tabulacji podczas używania spacji na potrzeby wcięć. Zaznaczanie będzie nadal korzystać z tabulatorów.",
"suggest.filterGraceful": "Określa, czy sugestie filtrowania i sortowania na kontach uwzględniają małe literówki.",
"suggest.insertMode": "Określa, czy wyrazy są zastępowane podczas akceptowania uzupełnień. Należy pamiętać, że zależy to od rozszerzeń korzystających z tej funkcji.",
"suggest.insertMode.always": "Zawsze wybieraj sugestię podczas automatycznego wyzwalania funkcji IntelliSense.",
"suggest.insertMode.insert": "Wstaw sugestię bez zastępowania tekstu z prawej strony kursora.",
"suggest.insertMode.never": "Nigdy nie wybieraj sugestii podczas automatycznego wyzwalania funkcji IntelliSense.",
"suggest.insertMode.replace": "Wstaw sugestię i zastąp tekst z prawej strony kursora.",
"suggest.insertMode.whenQuickSuggestion": "Wybierz sugestię tylko podczas wyzwalania funkcji IntelliSense podczas pisania.",
"suggest.insertMode.whenTriggerCharacter": "Wybierz sugestię tylko podczas wyzwalania funkcji IntelliSense przez znak wyzwalacza.",
"suggest.localityBonus": "Określa, czy sortowanie faworyzuje wyrazy, które pojawiają się w pobliżu kursora.",
"suggest.maxVisibleSuggestions.dep": "To ustawienie jest przestarzałe. Można teraz zmienić rozmiar widżetu sugestii.",
"suggest.preview": "Kontroluje, czy ma być dostępny podgląd wyników sugestii w edytorze.",
"suggest.selectionMode": "Steruje, czy sugestia jest wybierana podczas pokazywania widżetu. Pamiętaj, że ma to zastosowanie tylko do automatycznie wyzwalanych sugestii („#editor.quickSuggestions#” i „#editor.suggestOnTriggerCharacters#”) oraz że sugestia jest zawsze wybierana, gdy jest wywoływana jawnie, np. przez polecenie „Ctrl+Space”.",
"suggest.shareSuggestSelections": "Określa, czy zapamiętane wybory sugestii są współużytkowane przez wiele obszarów roboczych i okien (wymaga ustawienia „#editor.suggestSelection#”).",
"suggest.showIcons": "Określa, czy ikony mają być pokazywane, czy ukrywane w sugestiach.",
"suggest.showInlineDetails": "Określa, czy szczegóły sugestii mają być wyświetlane śródwierszowo z etykietą, czy tylko w widżecie szczegółów",
"suggest.showInlineDetails": "Określa, czy szczegóły sugestii mają być wyświetlane śródwierszowo z etykietą, czy tylko w widżecie szczegółów.",
"suggest.showStatusBar": "Steruje widocznością paska stanu u dołu widżetu sugestii.",
"suggest.snippetsPreventQuickSuggestions": "Określa, czy aktywny fragment kodu uniemożliwia szybkie sugestie.",
"suggestFontSize": "Rozmiar czcionki dla widżetu sugestii. W przypadku ustawienia wartości „0” używane będzie ustawienie „#editor.fontSize#”.",
"suggestLineHeight": "Wysokość wiersza dla widżetu sugestii. W przypadku ustawienia wartości „0” będzie używane ustawienie „#editor.lineHeight#”. Wartość minimalna to 8.",
"suggestFontSize": "Rozmiar czcionki dla widżetu sugestii. W przypadku ustawienia na wartość {0} używana jest wartość {1}.",
"suggestLineHeight": "Wysokość wiersza dla widżetu sugestii. W przypadku ustawienia na wartość {0} używana jest wartość {1}. Wartość minimalna to 8.",
"suggestOnTriggerCharacters": "Określa, czy sugestie powinny być automatycznie wyświetlane podczas wpisywania znaków wyzwalacza.",
"suggestSelection": "Określa sposób wstępnego wybierania sugestii podczas wyświetlania listy sugestii.",
"suggestSelection.first": "Zawsze wybieraj pierwszą sugestię.",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Wyłącz uzupełnianie po naciśnięciu klawisza Tab.",
"tabCompletion.on": "Zakończenie klawiszem Tab spowoduje wstawienie najlepiej pasującej sugestii po naciśnięciu klawisza Tab.",
"tabCompletion.onlySnippets": "Naciśnięcie klawisza Tab uzupełnia fragmenty kodu, gdy ich prefiks jest zgodny. Sprawdza się najlepiej, gdy sugestie „quickSuggestions” nie są włączone.",
"tabFocusMode": "Określa, czy edytor odbiera karty, czy odracza je do środowiska roboczego na potrzeby nawigacji.",
"unfoldOnClickAfterEndOfLine": "Określa, czy kliknięcie pustej zawartości po złożonym wierszu spowoduje rozwinięcie wiersza.",
"unicodeHighlight.allowedCharacters": "Definiuje dozwolone znaki, które nie są wyróżniane.",
"unicodeHighlight.allowedLocales": "Znaki Unicode, które są wspólne w dozwolonych ustawieniach regionalnych, nie są wyróżniane.",
"unicodeHighlight.ambiguousCharacters": "Określa, czy są wyróżniane znaki, które można pomylić z podstawowymi znakami ASCII, z wyjątkiem tych, które są typowe w bieżących ustawieniach regionalnych użytkownika.",
"unicodeHighlight.includeComments": "Określa, czy znaki w komentarzach również powinny podlegać wyróżnianiu unicode.",
"unicodeHighlight.includeStrings": "Określa, czy znaki w ciągach również powinny podlegać wyróżnianiu Unicode.",
"unicodeHighlight.includeComments": "Określa, czy znaki w komentarzach również powinny podlegać wyróżnianiu standardu Unicode.",
"unicodeHighlight.includeStrings": "Określa, czy znaki w ciągach również powinny podlegać wyróżnianiu standardu Unicode.",
"unicodeHighlight.invisibleCharacters": "Określa, czy znaki, które tylko rezerwują miejsce lub nie mają żadnej szerokości, są wyróżniane.",
"unicodeHighlight.nonBasicASCII": "Określa, czy wszystkie znaki ASCII inne niż podstawowe są wyróżnione. Tylko znaki z zakresu od U+0020 do U+007E, tab, line-feed i carriage-return są traktowane jako podstawowe ASCII.",
"unusualLineTerminators": "Usuń nietypowe terminatory wierszy, które mogą powodować problemy.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Nietypowe terminatory wiersza są ignorowane.",
"unusualLineTerminators.prompt": "Dla nietypowych terminatorów wiersza wyświetlany jest monit o ich usunięcie.",
"useTabStops": "Wstawianie i usuwanie odstępów następuje po tabulatorach.",
"wordBreak": "Kontroluje reguły podziału wyrazów używane w przypadku tekstu w języku chińskim/japońskim/koreańskim (CJK).",
"wordBreak.keepAll": "Podziały wyrazów nie powinny być używane w przypadku tekstu w języku chińskim/japońskim/koreańskim (CJK). Zachowanie tekstu w innych językach jest takie samo jak w przypadku zwykłego tekstu.",
"wordBreak.normal": "Użyj domyślnej reguły podziału wiersza.",
"wordSeparators": "Znaki, które będą używane jako separatory wyrazów podczas wykonywania nawigacji lub operacji związanych z wyrazami",
"wordWrap": "Kontroluje sposób zawijania wierszy.",
"wordWrap.bounded": "Wiersze będą zawijane przy minimum krawędzi okienka ekranu i szerokości „#editor.wordWrapColumn#”.",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "Zawinięte wiersze otrzymują wcięcie +1 w kierunku nadrzędnego.",
"wrappingIndent.none": "Brak wcięcia. Zawijane wiersze zaczynają się w kolumnie 1.",
"wrappingIndent.same": "Zawinięte wiersze mają takie samo wcięcie jak element nadrzędny.",
"wrappingStrategy": "Steruje algorytmem, który oblicza punkty zawijania.",
"wrappingStrategy": "Steruje algorytmem, który oblicza punkty zawijania. Pamiętaj, że w trybie ułatwień dostępu, zaawansowane będą używane w celu uzyskania najlepszego środowiska.",
"wrappingStrategy.advanced": "Deleguje obliczenia punktów zawijania do przeglądarki. Jest to powolny algorytm, który może powodować zawieszanie się w przypadku dużych plików, ale działa poprawnie we wszystkich przypadkach.",
"wrappingStrategy.simple": "Zakłada, że wszystkie znaki mają tę samą szerokość. Jest to szybki algorytm, który działa poprawnie w przypadku czcionek o stałej szerokości i określonych skryptów (takich jak znaki alfabetu łacińskiego), w których symbole mają taką samą szerokość."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Kolor tła prowadnic par nieaktywnych nawiasów (6). Wymaga włączenia prowadnic par nawiasów.",
"editorCodeLensForeground": "Kolor pierwszego planu wskaźników CodeLens edytora",
"editorCursorBackground": "Kolor tła kursora edytora. Umożliwia dostosowywanie koloru znaku, na który nakłada się kursor blokowy.",
"editorDimmedLineNumber": "Kolor końcowego wiersza edytora, gdy element editor.renderFinalNewline jest ustawiony na wygaszony.",
"editorGhostTextBackground": "Kolor tła dla tekstu widma w edytorze.",
"editorGhostTextBorder": "Kolor obramowania tekstu widmo w edytorze.",
"editorGhostTextForeground": "Kolor pierwszego planu tekstu widma w edytorze.",
"editorGutter": "Kolor tła marginesu edytora. Margines zawiera marginesy symboli i numery wierszy.",
"editorIndentGuides": "Kolor prowadnic wcięć edytora.",
"editorLineNumbers": "Kolor numerów wierszy edytora.",
"editorOverviewRulerBackground": "Kolor tła linijki przeglądu edytora. Używany tylko wtedy, gdy minimapa jest włączona i umieszczona po prawej stronie edytora.",
"editorOverviewRulerBackground": "Kolor tła linijki przeglądu edytora.",
"editorOverviewRulerBorder": "Kolor obramowania linijki przeglądu.",
"editorRuler": "Kolor linijek edytora.",
"editorUnicodeHighlight.background": "Kolor tła używany do wyróżniania znaków Unicode.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Naciśnięcie klawisza Tab w bieżącym edytorze spowoduje przeniesienie fokusu do następnego elementu, do którego można przenieść fokus. Polecenie {0} nie może być obecnie wyzwalane przez powiązanie klawiszy.",
"toggleHighContrast": "Przełącz motyw o dużym kontraście"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "Znaki: {0}",
"showMore": "Pokaż więcej ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Zestaw zakotwiczenia w {0}: {1}",
"cancelSelectionAnchor": "Anuluj zakotwiczenie zaznaczenia",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Kopiuj jako",
"miCopy": "&&Kopiuj",
"miCut": "Wy&&tnij",
"miPaste": "&&Wklej"
"miPaste": "&&Wklej",
"share": "Udostępnij"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Wystąpił nieznany błąd podczas stosowania akcji kodu"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Wystąpił nieznany błąd podczas stosowania akcji kodu",
"args.schema.apply": "Steruje stosowaniem zwracanych akcji.",
"args.schema.apply.first": "Zawsze stosuj pierwszą zwróconą akcję kodu.",
"args.schema.apply.ifSingle": "Zastosuj pierwszą zwróconą akcję kodu, jeśli jest jedyna.",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Organizuj importy",
"quickfix.trigger.label": "Szybka poprawka...",
"refactor.label": "Refaktoryzuj...",
"refactor.preview.label": "Refaktoryzacja z podglądem...",
"source.label": "Akcja źródłowa..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Włącz/wyłącz wyświetlanie nagłówków grup w menu akcji kodu."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Przepisać...",
"codeAction.widget.id.extract": "Wyodrębnij...",
"codeAction.widget.id.inline": "Śródwierszowe...",
"codeAction.widget.id.more": "Więcej akcji...",
"codeAction.widget.id.move": "Przenieś...",
"codeAction.widget.id.quickfix": "Szybka poprawka...",
"codeAction.widget.id.source": "Akcja źródłowa...",
"codeAction.widget.id.surround": "Otocz za pomocą..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Ukryj wyłączone",
"showMoreActions": "Pokaż wyłączone"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Pokaż akcje kodu",
"codeActionWithKb": "Pokaż akcje kodu ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "&&Przełącz komentarz wiersza"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Pokaż menu kontekstowe edytora"
"action.showContextMenu.label": "Pokaż menu kontekstowe edytora",
"context.minimap.minimap": "Minimapa",
"context.minimap.renderCharacters": "Renderowanie znaków",
"context.minimap.size": "Rozmiar pionowy",
"context.minimap.size.fill": "Wypełnienie",
"context.minimap.size.fit": "Dopasuj",
"context.minimap.size.proportional": "Proporcjonalnie",
"context.minimap.slider": "Suwak",
"context.minimap.slider.always": "Zawsze",
"context.minimap.slider.mouseover": "Mysz nad"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Włącz/wyłącz uruchamianie edycji z rozszerzeń przy wklejeniu."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Trwa uruchamianie procedur obsługi wklejania..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Wykonaj ponownie kursor",
"cursor.undo": "Cofnij kursor"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Trwa uruchamianie procedur obsługi upuszczania..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Czy w edytorze jest uruchamiana operacja możliwa do anulowania, na przykład „Wgląd w odwołania”"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Przesłania flagę „Math Case”.\r\nFlaga nie zostanie zapisana w przyszłości.\r\n0: Nic nie rób\r\n1. Prawda\r\n2. Fałsz",
"actions.find.preserveCaseOverride": "Przesłania flagę „Preserve Case”.\r\nFlaga nie zostanie zapisana w przyszłości.\r\n0: Nic nie rób\r\n1. Prawda\r\n2. Fałsz",
"actions.find.wholeWordOverride": "Przesłania flagę „Match Whole Word”.\r\nFlaga nie zostanie zapisana w przyszłości.\r\n0: Nic nie rób\r\n1. Prawda\r\n2. Fałsz",
"findMatchAction.goToMatch": "Przejdź do pozycji Dopasuj...",
"findMatchAction.inputPlaceHolder": "Wpisz liczbę, aby przejść do określonego dopasowania (od 1 do {0})",
"findMatchAction.inputValidationMessage": "Wpisz liczbę z zakresu od 1 do {0}",
"findNextMatchAction": "Znajdź następny",
"findPreviousMatchAction": "Znajdź poprzedni",
"miFind": "&&Znajdź",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Tylko pierwsze wyniki ({0}) są wyróżnione, ale wszystkie operacje znajdowania działają na całym tekście."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Kolor kontrolki składania na marginesie edytora.",
"createManualFoldRange.label": "Utwórz zakres składania na podstawie zaznaczenia",
"foldAction.label": "Złóż",
"foldAllAction.label": "Złóż wszystko",
"foldAllBlockComments.label": "Złóż wszystkie komentarze blokowe",
"foldAllExcept.label": "Złóż wszystkie regiony z wyjątkiem wybranych",
"foldAllMarkerRegions.label": "Złóż wszystkie regiony",
"foldBackgroundBackground": "Kolor tła za złożonym zakresami. Kolor nie może być nieprzezroczysty, aby nie ukrywać podstawowych dekoracji.",
"foldLevelAction.label": "Poziom składania {0}",
"foldRecursivelyAction.label": "Składaj cyklicznie",
"gotoNextFold.label": "Przejdź do następnego zakresu składania",
"gotoParentFold.label": "Przeskocz do składania nadrzędnego",
"gotoPreviousFold.label": "Przejdź do poprzedniego zakresu składania",
"maximum fold ranges": "Liczba regionów składanych jest ograniczona do maksymalnie {0}. Zwiększ opcję konfiguracji [„Składane maksymalne regiony'](command:workbench.action.openSettings?[ „editor.foldingMaximumRegions”]) aby włączyć więcej.",
"removeManualFoldingRanges.label": "Usuń zakresy ręcznego składania",
"toggleFoldAction.label": "Przełącz złożenie",
"unFoldRecursivelyAction.label": "Rozłóż rekursywnie",
"unfoldAction.label": "Rozłóż",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Rozłóż wszystkie regiony"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Kolor kontrolki składania na marginesie edytora.",
"foldBackgroundBackground": "Kolor tła za złożonym zakresami. Kolor nie może być nieprzezroczysty, aby nie ukrywać podstawowych dekoracji.",
"foldingCollapsedIcon": "Ikona zwiniętych zakresów na marginesie symboli edytora.",
"foldingExpandedIcon": "Ikona dla rozwiniętych zakresów na marginesie symboli edytora."
"foldingExpandedIcon": "Ikona dla rozwiniętych zakresów na marginesie symboli edytora.",
"foldingManualCollapedIcon": "Ikona dla ręcznie zwiniętych zakresów na marginesie symbolu edytora.",
"foldingManualExpandedIcon": "Ikona ręcznie rozwiniętych zakresów na marginesie symboli edytora."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Powiększenie czcionki edytora",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Trwa ładowanie...",
"stopped rendering": "Renderowanie zostało wstrzymane dla długiego wiersza ze względu na wydajność. Można to skonfigurować za pomocą polecenia `editor.stopRenderingLineAfter`.",
"too many characters": "Tokenizacja jest pomijana dla długich wierszy ze względu na wydajność. Można to skonfigurować za pośrednictwem elementu „editor.maxTokenizationLineLength”."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Wyświetl problem"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Zmień rozmiar wyświetlania karty",
"configuredTabSize": "Skonfigurowany rozmiar karty",
"currentTabSize": "Rozmiar bieżącej karty",
"defaultTabSize": "Domyślny rozmiar karty",
"detectIndentation": "Wykryj wcięcia na podstawie zawartości",
"editor.reindentlines": "Ponowne wcięcie wierszy",
"editor.reindentselectedlines": "Ponowne wcięcie zaznaczonych wierszy",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "CMD + kliknięcie"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Akceptuj",
"acceptWord": "Zaakceptuj słowo",
"action.inlineSuggest.accept": "Zaakceptuj wbudowaną sugestię",
"action.inlineSuggest.acceptNextWord": "Zaakceptuj następny wyraz sugestii wbudowanej",
"action.inlineSuggest.alwaysShowToolbar": "Zawsze pokazuj pasek narzędzi",
"action.inlineSuggest.hide": "Ukryj sugestię wbudowaną",
"action.inlineSuggest.showNext": "Pokaż następną wbudowaną sugestię",
"action.inlineSuggest.showPrevious": "Pokaż poprzednią wbudowaną sugestię",
"action.inlineSuggest.trigger": "Wyzwól sugestię wbudowaną",
"action.inlineSuggest.undo": "Cofnij Zaakceptuj słowo",
"alwaysShowInlineSuggestionToolbar": "Czy wbudowany pasek narzędzi sugestii powinien być zawsze widoczny",
"canUndoInlineSuggestion": "Czy cofnięcie spowoduje cofnięcie sugestii wbudowanej",
"inlineSuggestionHasIndentation": "Czy wbudowana sugestia zaczyna się od białych znaków",
"inlineSuggestionHasIndentationLessThanTabSize": "Czy wbudowana sugestia zaczyna się od białych znaków, która jest mniejsza niż to, co zostałoby wstawione przez tabulator",
"inlineSuggestionVisible": "Czy wbudowana sugestia jest widoczna"
"inlineSuggestionVisible": "Czy wbudowana sugestia jest widoczna",
"undoAcceptWord": "Cofnij Zaakceptuj słowo"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Sugestia:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Następne",
"parameterHintsNextIcon": "Ikona do pokazywania następnej wskazówki dotyczącą parametru.",
"parameterHintsPreviousIcon": "Ikona do pokazywania poprzedniej wskazówki dotyczącej parametru.",
"previous": "Poprzednie"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Zamień na następną wartość",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Duplikuj zaznaczenie",
"editor.transformToCamelcase": "Przekształć w przypadek wielbłąda",
"editor.transformToKebabcase": "Przekształć w przypadek Kebab",
"editor.transformToLowercase": "Przekształć na małe litery",
"editor.transformToSnakecase": "Przekształć do pisowni z podkreśleniami zamiast spacji",
"editor.transformToTitlecase": "Przekształć do wielkości liter jak w nazwach własnych",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Wykonaj polecenie {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Nie można edytować w edytorze tylko do odczytu",
"messageVisible": "Czy edytor aktualnie pokazuje komunikat osadzony"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Przenieś ostatnie zaznaczenie do poprzedniego dopasowania wyszukiwania",
"mutlicursor.addCursorsToBottom": "Dodaj kursory na dole",
"mutlicursor.addCursorsToTop": "Dodaj kursory na górze",
"mutlicursor.focusNextCursor": "Ustaw fokus na następnym kursorze",
"mutlicursor.focusNextCursor.description": "Ustawia fokus na następnym kursorze",
"mutlicursor.focusPreviousCursor": "Ustaw fokus na poprzednim kursorze",
"mutlicursor.focusPreviousCursor.description": "Ustawia fokus na poprzednim kursorze",
"mutlicursor.insertAbove": "Dodaj kursor powyżej",
"mutlicursor.insertAtEndOfEachLineSelected": "Dodaj kursory do końców wierszy",
"mutlicursor.insertBelow": "Dodaj kursor poniżej",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Kolor tła marginesu w edytorze widoku wglądu.",
"peekViewEditorMatchHighlight": "Dopasuj kolor wyróżnienia w edytorze widoku wglądu.",
"peekViewEditorMatchHighlightBorder": "Dopasuj obramowanie wyróżnienia w edytorze widoku wglądu.",
"peekViewEditorStickScrollBackground": "Kolor tła przylepnego przewijania w edytorze podglądu widoku.",
"peekViewResultsBackground": "Kolor tła listy wyników widoku wglądu.",
"peekViewResultsFileForeground": "Kolor pierwszego planu węzłów plików na liście wyników widoku wglądu.",
"peekViewResultsMatchForeground": "Kolor pierwszego planu węzłów wierszy na liście wyników widoku wglądu.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "parametry typu ({0})",
"variable": "zmienne ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Nie można edytować w edytorze tylko do odczytu",
"editor.simple.readonly": "Nie można edytować w danych wejściowych tylko do odczytu"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "Pomyślnie zmieniono nazwę elementu „{0}” na „{1}”. Podsumowanie: {2}",
"enablePreview": "Włącz/wyłącz możliwość wyświetlania podglądu zmian przed zmianą nazwy",
"label": "Zmienianie nazwy elementu „{0}”",
"label": "Zmienianie nazwy z „{0}” na „{1}”",
"no result": "Brak wyniku.",
"quotableLabel": "Zmienianie nazwy {0}",
"quotableLabel": "Zmienianie nazwy z „{0}” na „{1}”",
"rename.failed": "Zmiana nazwy nie może obliczyć edycji",
"rename.failedApply": "Zmiana nazwy nie może zastosować edycji",
"rename.label": "Zmień nazwę symbolu",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Określa, czy w trybie fragmentów kodu jest dostępny następny tabulator",
"hasPrevTabstop": "Określa, czy w trybie fragmentów kodu jest dostępny poprzedni tabulator",
"inSnippetMode": "Określa, czy edytor jest bieżący w trybie fragmentów kodu"
"inSnippetMode": "Określa, czy edytor jest bieżący w trybie fragmentów kodu",
"next": "Przejdź do następnego symbolu zastępczego..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Kwiecień",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Środa",
"WednesdayShort": "Śro"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Przewijanie przylepne",
"mitoggleStickyScroll": "&&Przełącz przewijanie przylepne",
"stickyScroll": "Przewijanie przylepne",
"toggleStickyScroll": "Przełącz przewijanie przylepne"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Określa, czy sugestie są wstawiane po naciśnięciu klawisza Enter",
"suggestWidgetDetailsVisible": "Określa, czy szczegóły sugestii są widoczne",
"suggestWidgetHasSelection": "Określa, czy dowolna sugestia ma fokus",
"suggestWidgetMultipleSuggestions": "Określa, czy jest dostępnych wiele sugestii do wyboru",
"suggestionCanResolve": "Określa, czy bieżąca sugestia obsługuje rozpoznawanie dalszych szczegółów",
"suggestionHasInsertAndReplaceRange": "Określa, czy bieżąca sugestia ma zachowanie wstawiania i zamiany",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Ikona do uzyskiwania dodatkowych informacji w widżecie sugestii."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Kolor pierwszego planu symboli tablic. Te symbole pojawiają się w konspekcie, linku do strony nadrzędnej i widgecie sugestii.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "Plik „{0}” zawiera co najmniej jeden nietypowy element końcowy wiersza, taki jak separator wierszy (LS) lub separator akapitów (PS).\r\n\r\nZaleca się usunięcie ich z pliku. Można to skonfigurować za pomocą elementu „editor.unusualLineTerminators”.",
"unusualLineTerminators.fix": "Usuń Nietypowe elementy końcowe wiersza",
"unusualLineTerminators.fix": "&&Usuń nietypowe elementy końcowe wiersza",
"unusualLineTerminators.ignore": "Ignoruj",
"unusualLineTerminators.message": "Wykryto nietypowe elementy końcowe wiersza",
"unusualLineTerminators.title": "Nietypowe elementy końcowe wiersza"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Kolor znacznika linijki przeglądu na potrzeby wyróżniania symboli. Kolor nie może być nieprzezroczysty, aby nie ukrywać podstawowych dekoracji.",
"overviewRulerWordHighlightStrongForeground": "Kolor znacznika linijki przeglądu na potrzeby wyróżniania symboli z dostępem do zapisu. Kolor nie może być nieprzezroczysty, aby nie ukrywać podstawowych dekoracji.",
"overviewRulerWordHighlightTextForeground": "Kolor znacznika linijki przeglądu tekstowego wystąpienia symbolu. Kolor musi być przezroczysty, aby nie ukrywać bazowych dekoracji.",
"wordHighlight": "Kolor tła symbolu podczas dostępu do odczytu, na przykład odczytywania zmiennej. Kolor nie może być nieprzezroczysty, aby nie ukrywać podstawowych dekoracji.",
"wordHighlight.next.label": "Przejdź do następnego wyróżnienia symbolu",
"wordHighlight.previous.label": "Przejdź do poprzedniego wyróżnienia symbolu",
"wordHighlight.trigger.label": "Wyzwól wyróżnienie symbolu",
"wordHighlightBorder": "Kolor obramowania symbolu podczas dostępu do odczytu, takiego jak w przypadku odczytywania zmiennej.",
"wordHighlightStrong": "Kolor tła symbolu podczas dostępu do zapisu, na przykład zapisywania do zmiennej. Kolor nie może być nieprzezroczysty, aby nie ukrywać podstawowych dekoracji.",
"wordHighlightStrongBorder": "Kolor obramowania symbolu podczas dostępu do zapisu, takiego jak w przypadku zapisywania do zmiennej."
"wordHighlightStrongBorder": "Kolor obramowania symbolu podczas dostępu do zapisu, takiego jak w przypadku zapisywania do zmiennej.",
"wordHighlightText": "Kolor tła tekstowego wystąpienia symbolu. Kolor musi być przezroczysty, aby nie ukrywać podstawowych dekoracji.",
"wordHighlightTextBorder": "Kolor obramowania tekstowego wystąpienia symbolu."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Przejdź do następnego wyróżnienia symbolu",
"wordHighlight.previous.label": "Przejdź do poprzedniego wyróżnienia symbolu",
"wordHighlight.trigger.label": "Wyzwól wyróżnienie symbolu"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Usuń słowo"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Deweloper",
"help": "Pomoc",
"preferences": "Preferencje",
"test": "Test",
"view": "Wyświetl"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Ukryj",
"resetThisMenu": "Resetuj menu"
},
"vs/platform/actions/common/menuService": {
"hide.label": "Ukryj element „{0}”"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Widżet akcji",
"customQuickFixWidget.labels": "{0}, przyczyna wyłączenia: {1}",
"label": "{0}, aby zastosować",
"label-preview": "{0} do zastosowania, {1} do wersji zapoznawczej"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Zaakceptuj wybraną akcję",
"codeActionMenuVisible": "Czy lista widżetów akcji jest widoczna",
"hideCodeActionWidget.title": "Ukryj widżet akcji",
"previewSelected.title": "Wyświetl podgląd wybranej akcji",
"selectNextCodeAction.title": "Wybierz następną akcję",
"selectPrevCodeAction.title": "Wybierz poprzednią akcję"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Usunięto linię różnicy",
"audioCues.diffLineInserted": "Wstawiono linię różnicy",
"audioCues.diffLineModified": "Zmodyfikowano linię różnicy",
"audioCues.lineHasBreakpoint.name": "Punkt przerwania w wierszu",
"audioCues.lineHasError.name": "Błąd w wierszu",
"audioCues.lineHasFoldedArea.name": "Składany obszar w wierszu",
"audioCues.lineHasInlineSuggestion.name": "Wbudowana sugestia w wierszu",
"audioCues.lineHasWarning.name": "Ostrzeżenie w wierszu",
"audioCues.noInlayHints": "Brak wskazówek typu Inlay w wierszu",
"audioCues.notebookCellCompleted": "Ukończono komórkę notesu",
"audioCues.notebookCellFailed": "Niepowodzenie komórki notesu",
"audioCues.onDebugBreak.name": "Zatrzymano debuger w punkcie przerwania",
"audioCues.taskCompleted": "Zadanie ukończone",
"audioCues.taskFailed": "Zadanie nie powiodło się",
"audioCues.terminalBell": "Dzwonek terminalu",
"audioCues.terminalCommandFailed": "Polecenie terminalu nie powiodło się",
"audioCues.terminalQuickFix.name": "Szybka poprawka terminalu"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "Nie można zarejestrować elementu „{0}”. Skojarzone zasady {1} są już zarejestrowane w {2}.",
"config.property.duplicate": "Nie można zarejestrować elementu „{0}”. Ta właściwość jest już zarejestrowana.",
"config.property.empty": "Nie można zarejestrować pustej właściwości",
"config.property.languageDefault": "Nie można zarejestrować elementu „{0}”. Jest on zgodny ze wzorcem właściwości „\\\\[.*\\\\]$” opisującym ustawienia edytora specyficzne dla języka. Użyj kontrybucji „configurationDefaults”.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Określa, czy system operacyjny to Linux",
"isMac": "Określa, czy system operacyjny to macOS",
"isMacNative": "Określa, czy system operacyjny to macOS na platformie innej niż przeglądarka",
"isMobile": "Czy platforma jest mobilną przeglądarką internetową",
"isWeb": "Określa, czy platforma to przeglądarka internetowa",
"isWindows": "Określa, czy system operacyjny to Windows"
"isWindows": "Określa, czy system operacyjny to Windows",
"productQualityType": "Typ jakości edytora VS Code"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Anuluj",
"moreFile": "...1 dodatkowy plik nie jest wyświetlony",
"moreFiles": "...dodatkowe pliki w liczbie {0} nie są wyświetlone"
"moreFiles": "...dodatkowe pliki w liczbie {0} nie są wyświetlone",
"okButton": "&&OK",
"yesButton": "&&Tak"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "Plik jest zbyt duży, aby można go było otworzyć jako edytor bez tytułu. Przekaż go najpierw do eksploratora plików, a następnie spróbuj ponownie."
},
"vs/platform/files/common/files": {
"sizeB": "{0} B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Mnożnik szybkości przewijania podczas naciskania klawisza „Alt”.",
"Mouse Wheel Scroll Sensitivity": "Mnożnik, który ma być używany w elementach „deltaX” i „deltaY” zdarzeń przewijania kółka myszy.",
"automatic keyboard navigation setting": "Kontroluje, czy nawigacja za pomocą klawiatury w listach i drzewach jest automatycznie wyzwalana przez rozpoczęcie pisania. Jeśli ustawiono wartość „false”, nawigacja za pomocą klawiatury jest wyzwalana tylko przez wykonanie polecenia „list.toggleKeyboardNavigation”, do którego można przypisać skrót klawiaturowy.",
"defaultFindMatchTypeSettingKey": "Określa typ dopasowania używany podczas wyszukiwania list i drzew w środowisku roboczym.",
"defaultFindMatchTypeSettingKey.contiguous": "Użyj ciągłego dopasowywania podczas wyszukiwania.",
"defaultFindMatchTypeSettingKey.fuzzy": "Podczas wyszukiwania używaj dopasowywania rozmytego.",
"defaultFindModeSettingKey": "Steruje domyślnym trybem znajdowania list i drzew w środowisku roboczym.",
"defaultFindModeSettingKey.filter": "Filtruj elementy podczas wyszukiwania.",
"defaultFindModeSettingKey.highlight": "Wyróżnij elementy podczas wyszukiwania. Nawigacja w górę i w dół będzie przechodzić tylko przez wyróżnione elementy.",
"expand mode": "Określa, w jaki sposób foldery drzewiaste są rozwijane po kliknięciu nazw folderów. Pamiętaj, że niektóre drzewa i listy mogą ignorować to ustawienie, jeśli nie ma zastosowania.",
"horizontalScrolling setting": "Kontroluje, czy listy i drzewa obsługują przewijanie w poziomie w środowisku roboczym. Ostrzeżenie: włączenie tego ustawienia wpływa na wydajność.",
"keyboardNavigationSettingKey": "Kontroluje styl nawigacji za pomocą klawiatury dla list i drzew na pulpicie. Dostępne są style prosty, wyróżnienia i filtru.",
"keyboardNavigationSettingKey.filter": "Funkcja filtrowania dla nawigacji za pomocą klawiatury powoduje odfiltrowanie i ukrycie wszystkich elementów, które nie pasują do danych wprowadzonych przy użyciu klawiatury.",
"keyboardNavigationSettingKey.highlight": "Wyróżnij elementy wyróżniania nawigacji za pomocą klawiatury, które pasują do danych wprowadzonych przy użyciu klawiatury. Dalsza nawigacja w górę i w dół będzie odbywać się tylko w ramach wyróżnionych elementów.",
"keyboardNavigationSettingKey.simple": "Prosta nawigacja klawiaturą skupia elementy zgodne z sygnałem z klawiatury. Dopasowywanie odbywa się tylko na prefiksach.",
"keyboardNavigationSettingKeyDeprecated": "Zamiast tego użyj poleceń „workbench.list.defaultFindMode” i „workbench.list.typeNavigationMode”.",
"list smoothScrolling setting": "Kontroluje, czy listy i drzewa są przewijane płynnie.",
"list.scrollByPage": "Określa, czy kliknięcie na pasku przewijania powoduje przewijanie całych stron.",
"multiSelectModifier": "Modyfikator do zastosowania w celu dodania elementu w drzewach i na listach przy wybieraniu wielu elementów za pomocą myszy (na przykład w eksploratorze, przy otwieraniu edytorów i w widoku SCM). Gesty myszy „Otwórz na bok” (jeśli są obsługiwane) dostosują się, tak aby nie powodować konfliktu z modyfikatorem wielokrotnego wyboru.",
"multiSelectModifier.alt": "Mapuje na klawisz „Alt” w systemach Windows i Linux oraz na klawisz „Option” w systemie MacOS.",
"multiSelectModifier.ctrlCmd": "Mapuje na klawisz „Control” w systemach Windows i Linux oraz na klawisz „Command” w systemie MacOS.",
"openModeModifier": "Steruje sposobem otwierania elementów w drzewach i na listach za pomocą myszy (jeśli jest to obsługiwane). Pamiętaj, że niektóre drzewa i listy mogą ignorować to ustawienie, jeśli nie ma zastosowania. ",
"render tree indent guides": "Kontroluje, czy drzewo ma wyświetlać prowadnice wcięć.",
"tree indent setting": "Kontroluje wcięcie drzewa w pikselach.",
"typeNavigationMode": "Określa sposób działania nawigacji dotyczącej wpisywania w listach i drzewach w środowisku roboczym. Jeśli ustawiono wartość „trigger”, nawigacja dotycząca wpisywania rozpocznie się po uruchomieniu polecenia „list.triggerTypeNavigation”.",
"workbenchConfigurationTitle": "Pulpit"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Ostrzeżenie"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "Polecenie „{0}” spowodowało błąd ({1})",
"canNotRun": "Polecenie „{0}” spowodowało błąd",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "często używane",
"morecCommands": "inne polecenia",
"recentlyUsed": "ostatnio używane"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "polecenia edytora",
"globalCommands": "polecenia globalne",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Niestandardowe",
"inputModeEntry": "Naciśnij klawisz „Enter”, aby potwierdzić dane wejściowe, lub klawisz „Escape”, aby anulować",
"inputModeEntryDescription": "{0} (naciśnij klawisz „Enter”, aby potwierdzić, lub klawisz „Escape”, aby anulować)",
"ok": "OK",
"quickInput.back": "Wstecz",
"quickInput.backWithKeybinding": "Wstecz ({0})",
"quickInput.checkAll": "Przełącz wszystkie pola wyboru",
"quickInput.countSelected": "Liczba wybranych: {0}",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "Liczba wyników: {0}",
"quickInputBox.ariaLabel": "Wpisz, aby zawęzić wyniki."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Szybkie wejście"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Kliknij, aby wykonać polecenie „{0}”"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Dodatkowe obramowanie wokół aktywnych elementów oddzielające je od innych w celu zwiększenia kontrastu.",
"activeLinkForeground": "Kolor aktywnych linków.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Kolor tła elementów nawigacji.",
"breadcrumbsFocusForeground": "Kolor elementów nawigacji z fokusem.",
"breadcrumbsSelectedBackground": "Kolor tła selektora elementu nawigacji.",
"breadcrumbsSelectedForegound": "Kolor wybranych elementów nawigacji.",
"breadcrumbsSelectedForeground": "Kolor wybranych elementów nawigacji.",
"buttonBackground": "Kolor tła przycisku.",
"buttonBorder": "Kolor obramowania przycisku.",
"buttonForeground": "Kolor pierwszego planu przycisku.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Pomocniczy kolor tła przycisku.",
"buttonSecondaryForeground": "Pomocniczy kolor pierwszego planu przycisku.",
"buttonSecondaryHoverBackground": "Pomocniczy kolor tła przycisku podczas aktywowania.",
"buttonSeparator": "Kolor separatora przycisku.",
"chartsBlue": "Kolor niebieski używany w wizualizacjach wykresów.",
"chartsForeground": "Kolor pierwszego planu używany na wykresach.",
"chartsGreen": "Kolor zielony używany w wizualizacjach wykresów.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Kolor tła widżetu pola wyboru.",
"checkbox.border": "Kolor obramowania widżetu pola wyboru.",
"checkbox.foreground": "Kolor pierwszego planu widżetu pola wyboru.",
"checkbox.select.background": "Kolor tła widżetu pola wyboru, gdy element, w którym się znajduje, jest zaznaczony.",
"checkbox.select.border": "Kolor obramowania widżetu pola wyboru, gdy element, w którym się znajduje, jest zaznaczony.",
"contrastBorder": "Dodatkowe obramowanie wokół elementów oddzielające je od innych w celu zwiększenia kontrastu.",
"descriptionForeground": "Kolor pierwszego planu dla tekstu opisu z dodatkowymi informacjami, na przykład etykiety.",
"diffDiagonalFill": "Kolor wypełnienia ukośnego w edytorze różnic. Wypełnienie ukośne jest używane w widokach wyświetlania różnic obok siebie.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Kolor tła marginesu, z którego usunięto wiersze.",
"diffEditorRemovedLines": "Kolor tła wierszy, które zostały usunięte. Kolor musi być przezroczysty, aby nie ukrywać dekoracji pod spodem.",
"diffEditorRemovedOutline": "Kolor konturu tekstu, który został usunięty.",
"disabledForeground": "Ogólny pierwszy plan dla wyłączonych elementów. Ten kolor jest używany tylko wtedy, gdy nie jest zastępowany przez składnik.",
"dropdownBackground": "Tło listy rozwijanej.",
"dropdownBorder": "Obramowanie listy rozwijanej.",
"dropdownForeground": "Pierwszy plan listy rozwijanej.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Kolor zaznaczonego tekstu dla dużego kontrastu.",
"editorSelectionHighlight": "Kolor regionów z taką samą zawartością jak zaznaczenie. Kolor nie może być nieprzezroczysty, aby nie ukrywać dekoracji pod spodem.",
"editorSelectionHighlightBorder": "Kolor obramowania regionów o tej samej zawartości co zaznaczenie.",
"editorStickyScrollBackground": "Przylepione przewijanie koloru tła dla edytora",
"editorStickyScrollHoverBackground": "Przylepione przewijanie po najechaniu kursorem na kolor tła dla edytora",
"editorWarning.background": "Kolor tła dla tekstu ostrzegawczego w edytorze. Kolor nie może być nieprzezroczysty, aby nie ukrywać dekoracji pod spodem.",
"editorWarning.foreground": "Kolor pierwszego planu dla zygzaków ostrzeżenia w edytorze.",
"editorWidgetBackground": "Kolor tła widżetów edytora, takich jak wyszukiwania/zamiany.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Kolor tła widżetu filtru typu w listach i drzewach.",
"listFilterWidgetNoMatchesOutline": "Kolor konturu widżetu filtra typów na listach i w drzewach, gdy nie ma dopasowań.",
"listFilterWidgetOutline": "Kolor konturu widżetu filtra typów na listach i w drzewach.",
"listFilterWidgetShadow": "Kolor cienia widżetu filtru typu na listach i drzewach.",
"listFocusAndSelectionOutline": "Kolor konturu listy/drzewa dla elementu priorytetowego, gdy lista/drzewo jest aktywne i zaznaczone. Aktywna lista/drzewo ma fokus klawiatury, a nieaktywna nie ma.",
"listFocusBackground": "Kolor tła listy/drzewa dla elementu z fokusem, gdy lista/drzewo jest aktywne. Aktywna lista/drzewo ma fokus klawiatury, a nieaktywna lista/drzewo nie ma.",
"listFocusForeground": "Kolor pierwszego planu listy/drzewa dla elementu z fokusem, gdy lista/drzewo jest aktywne. Aktywna lista/drzewo ma fokus klawiatury, a nieaktywna lista/drzewo nie ma.",
"listFocusHighlightForeground": "Kolor pierwszego planu listy/drzewa wyróżnień dopasowania na aktywnie priorytetowych elementach podczas wyszukiwania wewnątrz listy/drzewa.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Tło paska narzędzi podczas trzymania wskaźnika myszy nad akcjami",
"toolbarHoverBackground": "Tło paska narzędzi po umieszczeniu wskaźnika myszy na akcjach",
"toolbarHoverOutline": "Kontur paska narzędzi przy aktywowaniu akcji za pomocą myszy",
"treeInactiveIndentGuidesStroke": "Kolor pociągnięcia drzewa dla prowadnic wcięć, które nie są aktywne.",
"treeIndentGuidesStroke": "Kolor obrysu drzewa dla prowadnic wcięć.",
"warningBorder": "Kolor obramowania dla pól ostrzeżeń w edytorze.",
"widgetBorder": "Kolor obramowania widżetów, takich jak znajdowanie/zamienianie w edytorze.",
"widgetShadow": "Kolor cienia widżetów takich jak znajdź/zamień wewnątrz edytora."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Ikona akcji zamknięcia w widżetach."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Anuluj",
"cannotResourceRedoDueToInProgressUndoRedo": "Nie można wykonać ponownie operacji „{0}”, ponieważ jest już uruchomiona operacja cofania lub ponownego wykonania.",
"cannotResourceUndoDueToInProgressUndoRedo": "Nie można cofnąć operacji „{0}”, ponieważ jest już uruchomiona operacja cofania lub ponownego wykonania.",
"cannotWorkspaceRedo": "Nie można wykonać ponownie operacji „{0}” dla wszystkich plików. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "Nie można cofnąć operacji „{0}” dla wszystkich plików, ponieważ istnieje już operacja cofania lub ponownego uruchomienia dla plików {1}",
"confirmDifferentSource": "Czy chcesz cofnąć operację „{0}”?",
"confirmDifferentSource.no": "Nie",
"confirmDifferentSource.yes": "Tak",
"confirmDifferentSource.yes": "&&Tak",
"confirmWorkspace": "Czy chcesz cofnąć operację „{0}” dla wszystkich plików?",
"externalRemoval": "Następujące pliki zostały zamknięte i zmodyfikowane na dysku: {0}.",
"noParallelUniverses": "Następujące pliki zostały zmodyfikowane w niezgodny sposób: {0}.",
"nok": "Cofnij ten plik",
"ok": "Cofnij w {0} plikach"
"nok": "Cofnij ten &&plik",
"ok": "&&Cofnij w {0} plikach"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Obszar roboczy programu Code"

394
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/pt-br.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Mais Ações..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Fechar Caixa de Diálogo",
"dialogErrorMessage": "Erro",
"dialogInfoMessage": "Informações",
"dialogPendingMessage": "Em Andamento",
"dialogWarningMessage": "Aviso",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Mais Ações..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "entrada"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Diferenciar Maiúsculas de Minúsculas",
"regexDescription": "Usar Expressão Regular",
"wordsDescription": "Coincidir Palavra Inteira"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "entrada",
"label.preserveCaseToggle": "Preservar Maiúsculas e Minúsculas"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Não Associado"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Selecionar Caixa"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Mais Ações..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Limpar",
"disable filter on type": "Desabilitar Filtrar por Tipo",
"empty": "Nenhum elemento encontrado",
"enable filter on type": "Habilitar Filtrar por Tipo",
"found": "Foram correspondidos {0} de {1} elementos"
"close": "Fechar",
"filter": "Filtrar",
"fuzzySearch": "Correspondência Difusa",
"not found": "Nenhum elemento encontrado.",
"type to filter": "Digite para filtrar",
"type to search": "Digite para pesquisar"
},
"vs/base/common/actions": {
"submenu.empty": "(vazio)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Personalizado",
"inputModeEntry": "Pressione 'Enter' para confirmar sua entrada ou 'Escape' para cancelar",
"inputModeEntryDescription": "{0} (Pressione 'Enter' para confirmar ou 'Escape' para cancelar)",
"ok": "OK",
"quickInput.back": "Voltar",
"quickInput.backWithKeybinding": "Voltar ({0})",
"quickInput.countSelected": "{0} Selecionados",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} Resultados",
"quickInputBox.ariaLabel": "Digite para restringir os resultados."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Entrada Rápida"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "O editor não está acessível no momento. Pressione {0} para obter opções.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Desfazer"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "O número de cursores foi limitado a {0}."
"cursors.maximum": "O número de cursores foi limitado a {0}. Considere usar [localizar e substituir](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) para alterações maiores ou aumentar a configuração de limite de vários cursores do editor.",
"goToSetting": "Aumentar o Limite de Vários Cursores"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " usar Shift + F7 para navegar pelas alterações",
"diff.tooLarge": "Não é possível comparar arquivos porque um arquivo é muito grande.",
"diffInsertIcon": "Decoração de linha para inserções no editor de comparação.",
"diffRemoveIcon": "Decoração de linha para remoções no editor de comparação."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Controla se o editor mostra CodeLens.",
"detectIndentation": "Controla se `#editor.tabSize#` e `#editor.insertSpaces#` serão automaticamente detectados quando um arquivo for aberto com base no respectivo conteúdo.",
"detectIndentation": "Controla se {0} e {1} serão detectados automaticamente quando um arquivo for aberto com base no conteúdo do arquivo.",
"diffAlgorithm.experimental": "Usa um algoritmo de comparação experimental.",
"diffAlgorithm.smart": "Usa o algoritmo de comparação padrão.",
"editor.experimental.asyncTokenization": "Controla se a geração de tokens deve ocorrer de forma assíncrona em uma função de trabalho.",
"editorConfigurationTitle": "Editor",
"ignoreTrimWhitespace": "Quando habilitado, o editor de comparação ignora as alterações no espaço em branco à esquerda ou à direita.",
"insertSpaces": "Inserir espaços ao pressionar `Tab`. Esta configuração é substituída com base no conteúdo do arquivo quando `#editor.detectIndentation#` está ativo.",
"indentSize": "O número de espaços usados para recuo ou `\"tabSize\"` para usar o valor de '#editor.tabSize#'. Essa configuração é substituída com base no conteúdo do arquivo quando '#editor.detectIndentation#' estiver ativado.",
"insertSpaces": "Insira espaços ao pressionar 'Tab'. Essa configuração é substituída com base no conteúdo do arquivo quando {0} está ativado.",
"largeFileOptimizations": "Tratamento especial para arquivos grandes para desabilitar determinados recursos de uso intensivo de memória.",
"maxComputationTime": "Tempo limite em milissegundos após o cancelamento da computação de comparação. Use 0 para nenhum tempo limite.",
"maxFileSize": "Tamanho máximo do arquivo em MB para calcular as diferenças. Use 0 para nenhum limite.",
"maxTokenizationLineLength": "Linhas acima desse comprimento não serão indexadas por motivos de desempenho",
"renderIndicators": "Controla se o editor de comparação mostra indicadores +/- para alterações adicionadas/removidas.",
"renderMarginRevertIcon": "Quando ativado, o editor de diferenças mostra setas em sua margem de glifo para reverter as alterações.",
"schema.brackets": "Define os símbolos de colchetes que aumentam ou diminuem o recuo.",
"schema.closeBracket": "A sequência de caracteres de colchete de fechamento ou a sequência de caracteres.",
"schema.colorizedBracketPairs": "Define os pares de colchetes que são coloridos por seu nível de aninhamento se a colorização de par de colchetes estiver habilitada.",
@ -139,15 +160,15 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.false": "Realce de semântica desabilitado para todos os temas de cor.",
"semanticHighlighting.true": "Realce de semântica habilitado para todos os temas de cor.",
"sideBySide": "Controla se o editor de comparação mostra a comparação lado a lado ou embutida.",
"stablePeek": "Manter editores de espiada abertos mesmo ao clicar duas vezes no conteúdo deles ou ao pressionar `Escape`.",
"tabSize": "O número de espaços ao pressionar 'tab'. Esta configuração é substituída com base no conteúdo do arquivo quando `#editor.detectIndentation#` está ativo.",
"stablePeek": "Mantenha os editores de inspeção abertos mesmo ao clicar duas vezes em seu conteúdo ou ao pressionar `Escape`.",
"tabSize": "O número de espaços aos qual uma guia é igual. Essa configuração é substituída com base no conteúdo do arquivo quando {0} está ativado.",
"trimAutoWhitespace": "Remover o espaço em branco inserido automaticamente à direita.",
"wordBasedSuggestions": "Controla se as conclusões devem ser calculadas com base em palavras do documento.",
"wordBasedSuggestionsMode": "Controla em quais documentos as conclusões baseadas em palavras são computadas.",
"wordBasedSuggestionsMode.allDocuments": "Sugerir palavras de todos os documentos abertos.",
"wordBasedSuggestionsMode.currentDocument": "Sugerir palavras apenas do documento ativo.",
"wordBasedSuggestionsMode.matchingDocuments": "Sugerir palavras de todos os documentos abertos da mesma linguagem.",
"wordWrap.inherit": "As linhas serão quebradas automaticamente de acordo com a configuração de `#editor.wordWrap#`.",
"wordWrap.inherit": "As linhas serão encapsuladas de acordo com a configuração do {0}.",
"wordWrap.off": "As linhas nunca serão quebradas.",
"wordWrap.on": "As linhas serão quebradas na largura do visor."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Controla se as sugestões devem ser aceitas pressionando `Enter`, além de `Tab`. Ajuda a evitar ambiguidade entre a inserção de novas linhas ou a aceitação de sugestões.",
"acceptSuggestionOnEnterSmart": "Somente aceitar uma sugestão com `Enter` quando ela fizer uma alteração textual.",
"accessibilityPageSize": "Controla o número de linhas no editor que podem ser lidas por um leitor de tela de uma vez. Quando detectamos um leitor de tela, definimos o padrão automaticamente como 500. Aviso: esta opção afeta o desempenho para números maiores que o padrão.",
"accessibilitySupport": "Controla se o editor deve ser executado em um modo em que é otimizado para leitores de tela.",
"accessibilitySupport.auto": "O editor usará APIs de plataforma para detectar quando um Leitor de Tela está anexado.",
"accessibilitySupport.off": "O editor nunca será otimizado para uso com um Leitor de Tela.",
"accessibilitySupport.on": "O editor será otimizado permanentemente para uso com um Leitor de Tela.",
"accessibilitySupport": "Controla se a interface do usuário deve ser executada em um modo otimizado para leitores de tela.",
"accessibilitySupport.auto": "Usar APIs de plataforma para detectar quando um Leitor de Tela está conectado",
"accessibilitySupport.off": "Suponha que um leitor de tela não esteja conectado",
"accessibilitySupport.on": "Otimizar para uso com um Leitor de Tela",
"alternativeDeclarationCommand": "ID de comando alternativa que está sendo executada quando o resultado de 'Ir para Declaração' é a localização atual.",
"alternativeDefinitionCommand": "A ID de comando alternativa que está sendo executada quando o resultado de 'Ir para Definição' é a localização atual.",
"alternativeImplementationCommand": "A ID de comando alternativa que está sendo executada quando o resultado de 'Ir para Implementação' é a localização atual.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Controla se o editor deverá fechar as aspas automaticamente depois que o usuário adicionar aspas de abertura.",
"autoIndent": "Controla se o editor deve ajustar automaticamente o recuo quando os usuários digitam, colam, movem ou recuam linhas.",
"autoSurround": "Controla se o editor deve envolver as seleções automaticamente.",
"bracketPairColorization.enabled": "Controla se a colorização do par de colchetes está habilitada ou não. Use 'workbench.colorCustomizations' para substituir as cores de realce de colchetes.",
"bracketPairColorization.enabled": "Controla se a colorização do par de colchetes está habilitada ou não. Use {0} para substituir as cores de realce do colchete.",
"bracketPairColorization.independentColorPoolPerBracketType": "Controla se cada tipo de colchete tem seu próprio pool de cores independente.",
"codeActions": "Habilita a lâmpada de ação do código no editor.",
"codeActions": "Habilita a lâmpada de Ação do Código no editor.",
"codeLens": "Controla se o editor mostra CodeLens.",
"codeLensFontFamily": "Controla a família de fontes do CodeLens.",
"codeLensFontSize": "Controla o tamanho da fonte do CodeLens em pixels. Quando esta configuração é definida como `0`, será usado 90% do `#editor.fontSize#`.",
"codeLensFontSize": "Controla o tamanho da fonte do CodeLens em pixels. Quando é definida como 0, será usado 90% do `#editor.fontSize#`.",
"colorDecorators": "Controla se o editor deve renderizar o seletor de cor e os decoradores de cor embutidos.",
"colorDecoratorsLimit": "Controla o número máximo de decoradores de cores que podem ser renderizados em um editor de uma só vez.",
"columnSelection": "Permite que a seleção com o mouse e as teclas faça a seleção de coluna.",
"comments.ignoreEmptyLines": "Controla se linhas vazias devem ser ignoradas com as ações de alternância, adição ou remoção para comentários de linha.",
"comments.insertSpace": "Controla se um caractere de espaço é inserido durante o comentário.",
"copyWithSyntaxHighlighting": "Controla se o realce de sintaxe deve ser copiado para a área de transferência.",
"cursorBlinking": "Controla o estilo de animação do cursor.",
"cursorSmoothCaretAnimation": "Controla se a animação de cursor suave deve ser habilitada.",
"cursorSmoothCaretAnimation.explicit": "A animação de cursor suave é habilitada somente quando o usuário move o cursor com um gesto explícito.",
"cursorSmoothCaretAnimation.off": "A animação de cursor suave está desabilitada.",
"cursorSmoothCaretAnimation.on": "A animação de cursor suave está sempre habilitada.",
"cursorStyle": "Controla o estilo do cursor.",
"cursorSurroundingLines": "Controla o número mínimo de linhas visíveis à esquerda e à direita ao redor do cursor. Conhecido como 'scrollOff' ou 'scrollOffset' em alguns outros editores.",
"cursorSurroundingLines": "Controla o número mínimo de linhas iniciais visíveis (mínimo 0) e linhas finais (mínimo 1) ao redor do cursor. Conhecido como 'scrollOff' ou 'scrollOffset' em alguns outros editores.",
"cursorSurroundingLinesStyle": "Controla quando `cursorSurroundingLines` deve ser imposto.",
"cursorSurroundingLinesStyle.all": "`cursorSurroundingLines` é sempre imposto.",
"cursorSurroundingLinesStyle.default": "`cursorSurroundingLines` é imposto somente quando disparado via teclado ou API.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Controla se o gesto do mouse Ir para Definição sempre abre o widget de espiada.",
"deprecated": "Esta configuração foi preterida. Use configurações separadas como 'editor.suggest.showKeywords' ou 'editor.suggest.showSnippets'.",
"dragAndDrop": "Controla se o editor deve permitir a movimentação de seleções por meio de arrastar e soltar.",
"dropIntoEditor.enabled": "Controla se você pode arrastar e soltar um arquivo em um editor de texto mantendo pressionada a tecla `shift` (em vez de abrir o arquivo em um editor).",
"editor.autoClosingBrackets.beforeWhitespace": "Fechar automaticamente os colchetes somente quando o cursor estiver à esquerda do espaço em branco.",
"editor.autoClosingBrackets.languageDefined": "Usar as configurações de linguagem para determinar quando fechar automaticamente os colchetes.",
"editor.autoClosingDelete.auto": "Remover as aspas ou os colchetes de fechamento adjacentes somente se eles foram inseridos automaticamente.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Habilita guias horizontais como adição a guias de par de colchetes verticais.",
"editor.guides.highlightActiveBracketPair": "Controla se o editor deve destacar o par de colchetes ativo.",
"editor.guides.highlightActiveIndentation": "Controla se o editor deve realçar a guia de recuo ativo.",
"editor.guides.highlightActiveIndentation.always": "Realça o guia de recuo ativo mesmo se as guias de colchetes estiverem realçadas.",
"editor.guides.highlightActiveIndentation.false": "Não realçar o guia de recuo ativo.",
"editor.guides.highlightActiveIndentation.true": "Realçar o guia de recuo ativo.",
"editor.guides.indentation": "Controla se o editor deve renderizar guias de recuo.",
"editor.inlayHints.off": "As dicas embutidas estão desabilitadas",
"editor.inlayHints.offUnlessPressed": "As dicas de embutimento ficam ocultas por padrão e são exibidas ao segurar {0}",
"editor.inlayHints.on": "As dicas embutidas estão habilitadas",
"editor.inlayHints.onUnlessPressed": "As dicas de incrustação são exibidas por padrão e ocultadas ao segurar {0}",
"editor.stickyScroll": "Mostra os escopos atuais aninhados durante a rolagem na parte superior do editor.",
"editor.stickyScroll.": "Define o número máximo de linhas autoadesivas a serem mostradas.",
"editor.suggest.matchOnWordStartOnly": "Quando ativado, a filtragem IntelliSense requer que o primeiro caractere corresponda a uma palavra inicial, por exemplo, `c` no `Console` ou `WebContext`, mas _não_ na `descrição`. Quando desativado, o IntelliSense mostrará mais resultados, mas ainda os classificará por qualidade de correspondência.",
"editor.suggest.showClasss": "Quando habilitado, o IntelliSense mostra sugestões de `class`.",
"editor.suggest.showColors": "Quando habilitado, o IntelliSense mostra sugestões de `color`.",
"editor.suggest.showConstants": "Quando habilitado, o IntelliSense mostra sugestões de `constant`.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Quando habilitado, o IntelliSense mostra sugestões de `variable`.",
"editorViewAccessibleLabel": "Conteúdo do editor",
"emptySelectionClipboard": "Controla se a cópia sem uma seleção copia a linha atual.",
"experimentalWhitespaceRendering": "Controla se o espaço em branco é renderizado com um novo método experimental.",
"experimentalWhitespaceRendering.font": "Use um novo método de renderização com caracteres de fonte.",
"experimentalWhitespaceRendering.off": "Use o método de renderização estável.",
"experimentalWhitespaceRendering.svg": "Use um novo método de renderização com svgs.",
"fastScrollSensitivity": "Multiplicador de velocidade de rolagem ao pressionar `Alt`.",
"find.addExtraSpaceOnTop": "Controla se Localizar Widget deve adicionar linhas extras na parte superior do editor. Quando true, você poderá rolar para além da primeira linha quando Localizar Widget estiver visível.",
"find.autoFindInSelection": "Controla automaticamente a condição para habilitar a Localização na Seleção.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Habilita/Desabilita as ligaturas de fonte (os recursos de fonte 'calt' e 'liga'). Altere esta opção para uma cadeia de caracteres para obter o controle refinado da propriedade 'font-feature-settings' do CSS.",
"fontLigaturesGeneral": "Configura as ligaturas de fonte ou os recursos de fonte. Pode ser um booliano para habilitar/desabilitar ligaturas ou uma cadeia de caracteres para o valor da propriedade 'font-feature-settings' do CSS.",
"fontSize": "Controla o tamanho da fonte em pixels.",
"fontVariationSettings": "Propriedade CSS 'font-variation-settings' explícita. Em vez disso, um booleano pode ser passado se for necessário apenas traduzir o peso da fonte para as configurações de variação da fonte.",
"fontVariations": "Habilita/Desabilita a tradução de font-weight para font-variation-settings. Altere isso para uma cadeia de caracteres para controle refinado da propriedade CSS 'font-variation-settings'.",
"fontVariationsGeneral": "Configura variações de fonte. Pode ser um booleano para habilitar/desabilitar a tradução de font-weight para font-variation-settings ou uma cadeia de caracteres para o valor da propriedade CSS 'font-variation-settings'.",
"fontWeight": "Controla a espessura da fonte. Aceita palavras-chave \"normal\" e \"bold\" ou números entre 1 e 1.000.",
"fontWeightErrorMessage": "Somente palavras-chave \"normal\" e \"bold\" ou números entre 1 e 1.000 são permitidos.",
"formatOnPaste": "Controla se o editor deve formatar automaticamente o conteúdo colado. Um formatador precisa estar disponível e o formatador deve ser capaz de formatar um intervalo em um documento.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Controla se o foco é mostrado.",
"hover.sticky": "Controla se o foco deve permanecer visível quando o mouse é movido sobre ele.",
"inlayHints.enable": "Habilita as dicas embutidas no editor.",
"inlayHints.fontFamily": "Controla a família de fontes de dicas de incrustações no editor. Quando definido como vazio, o `#editor.fontFamily#` é usado.",
"inlayHints.fontSize": "Controla o tamanho da fonte das dicas embutidas no editor. Um padrão de 90% do `#editor.fontSize#` é usado quando o valor configurado é menor que `5` ou maior que o tamanho da fonte do editor.",
"inlayHints.fontFamily": "Controla a família de fontes de dicas de inlay no editor. Quando definido como vazio, o {0} é usado.",
"inlayHints.fontSize": "Controla o tamanho da fonte das dicas de inlay no editor. Por padrão, o {0} é usado quando o valor configurado é menor que {1} ou maior que o tamanho da fonte do editor.",
"inlayHints.padding": "Habilita o preenchimento em torno das sugestões embutidas no editor.",
"inline": "As Sugestões rápidas são mostradas como texto fantasma",
"inlineSuggest.enabled": "Controla se quer mostrar automaticamente sugestões em linha no editor.",
"inlineSuggest.showToolbar": "Controla quando mostrar a barra de ferramentas de sugestão embutida.",
"inlineSuggest.showToolbar.always": "Mostrar a barra de ferramentas de sugestão embutida sempre que uma sugestão embutida for mostrada.",
"inlineSuggest.showToolbar.onHover": "Mostrar a barra de ferramentas de sugestão embutida ao passar o mouse sobre uma sugestão embutida.",
"letterSpacing": "Controla o espaçamento de letras em pixels.",
"lineHeight": "Controla a altura da linha. \r\n - Use 0 para calcular automaticamente a altura da linha do tamanho da fonte.\r\n - Os valores entre 0 e 8 serão usados como um multiplicador com o tamanho da fonte.\r\n - Valores maiores ou iguais a 8 serão usados como valores efetivos.",
"lineNumbers": "Controla a exibição de números de linha.",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "Controla se o editor tem a edição vinculada habilitada. Dependendo da linguagem, os símbolos relacionados, por exemplo, a marcas HTML, são atualizados durante a edição.",
"links": "Controla se o editor deve detectar links e torná-los clicáveis.",
"matchBrackets": "Realçar colchetes correspondentes.",
"minimap.autohide": "Controla se o minimapa é ocultado automaticamente.",
"minimap.enabled": "Controla se o minimapa é exibido.",
"minimap.maxColumn": "Limitar a largura do minimapa para renderizar no máximo um determinado número de colunas.",
"minimap.renderCharacters": "Renderizar os caracteres reais em uma linha, em oposição aos blocos de cores.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "O minimapa tem o mesmo tamanho que o conteúdo do editor (e pode rolar).",
"mouseWheelScrollSensitivity": "Um multiplicador a ser usado no `deltaX` e no `deltaY` dos eventos de rolagem do mouse.",
"mouseWheelZoom": "Aplicar zoom à fonte do editor ao usar o botão de rolagem do mouse e segurar `Ctrl`.",
"multiCursorLimit": "Controla o número máximo de cursores que podem estar em um editor ativo ao mesmo tempo.",
"multiCursorMergeOverlapping": "Mesclar vários cursores quando eles estiverem sobrepostos.",
"multiCursorModifier": "The modifier to be used to add multiple cursors with the mouse. The Go to Definition and Open Link mouse gestures will adapt such that they do not conflict with the multicursor modifier. [Read more](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "O modificador a ser usado para adicionar vários cursores com o mouse. Os gestos do mouse Ir para Definição e Abrir Link irão adaptar-se de forma a não entrarem em conflito com o [modificador multicursor](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier.alt": "Mapeia para `Alt` no Windows e no Linux e para `Option` no macOS.",
"multiCursorModifier.ctrlCmd": "Mapeia para `Control` no Windows e no Linux e para `Command` no macOS.",
"multiCursorPaste": "Controla a colagem quando a contagem de linhas do texto colado corresponde à contagem do cursor.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Controla se deve focar o editor embutido ou a árvore no widget de espiada.",
"peekWidgetDefaultFocus.editor": "Focalizar o editor ao abrir a espiada",
"peekWidgetDefaultFocus.tree": "Focalizar a árvore ao abrir a espiada",
"quickSuggestions": "Controla se as sugestões devem ser exibidas automaticamente durante a digitação.",
"quickSuggestions": "Controla se as sugestões devem aparecer automaticamente durante a digitação. Isso pode ser controlado para digitar comentários, cadeias de caracteres e outros códigos. A sugestão rápida pode ser configurada para ser exibida como texto fantasma ou com o widget de sugestão. Esteja ciente também da configuração '{0}' que controla se as sugestões são acionadas por caracteres especiais.",
"quickSuggestions.comments": "Habilitar sugestões rápidas dentro de comentários.",
"quickSuggestions.other": "Habilitar sugestões rápidas fora de cadeias de caracteres e comentários.",
"quickSuggestions.strings": "Habilitar sugestões rápidas dentro de cadeias de caracteres.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Controla quando os controles de dobragem na medianiz são exibidos.",
"showFoldingControls.always": "Sempre mostrar os controles de dobragem.",
"showFoldingControls.mouseover": "Mostrar somente os controles de dobragem quando o mouse estiver sobre a medianiz.",
"showFoldingControls.never": "Nunca mostre os controles dobráveis e reduza o tamanho da calha.",
"showUnused": "Controla o esmaecimento do código não usado.",
"smoothScrolling": "Controla se o editor rolará usando uma animação.",
"snippetSuggestions": "Controla se os snippets são mostrados com outras sugestões e como são classificados.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Emular o comportamento da seleção dos caracteres de tabulação ao usar espaços para recuo. A seleção respeitará as paradas de tabulação.",
"suggest.filterGraceful": "Controla se a filtragem e classificação de sugestões considera erros pequenos de digitação.",
"suggest.insertMode": "Controla se as palavras são substituídas ao aceitar as conclusões. Observe que isso depende de extensões que optam por esse recurso.",
"suggest.insertMode.always": "Sempre selecione uma sugestão ao disparar automaticamente o IntelliSense.",
"suggest.insertMode.insert": "Inserir sugestão sem substituir o texto à direita do cursor.",
"suggest.insertMode.never": "Nunca selecione uma sugestão ao disparar automaticamente o IntelliSense.",
"suggest.insertMode.replace": "Inserir a sugestão e substituir o texto à direita do cursor.",
"suggest.insertMode.whenQuickSuggestion": "Selecione uma sugestão somente ao disparar o IntelliSense enquanto digita.",
"suggest.insertMode.whenTriggerCharacter": "Selecione uma sugestão somente ao disparar o IntelliSense de um caractere de gatilho.",
"suggest.localityBonus": "Controla se a classificação favorece palavras que aparecem próximas ao cursor.",
"suggest.maxVisibleSuggestions.dep": "Esta configuração foi preterida. Agora, o widget de sugestão pode ser redimensionado.",
"suggest.preview": "Controla se a visualização do resultado da sugestão é apresentada no editor.",
"suggest.selectionMode": "Controla se uma sugestão é selecionada quando o widget é exibido. Observe que isso só se aplica a sugestões disparadas automaticamente ('#editor.quickSuggestions#' e '#editor.suggestOnTriggerCharacters#') e que uma sugestão é sempre selecionada quando invocada explicitamente, por exemplo, por meio de 'Ctrl+Espaço'.",
"suggest.shareSuggestSelections": "Controla se as seleções de sugestão lembradas são compartilhadas entre vários workspaces e janelas (precisa de `#editor.suggestSelection#`).",
"suggest.showIcons": "Controla se os ícones em sugestões devem ser mostrados ou ocultados.",
"suggest.showInlineDetails": "Controla se os detalhes da sugestão são mostrados embutidos com o rótulo ou somente no widget de detalhes",
"suggest.showInlineDetails": "Controla se os detalhes da sugestão são mostrados embutidos com o rótulo ou somente no widget de detalhes.",
"suggest.showStatusBar": "Controla a visibilidade da barra de status na parte inferior do widget de sugestão.",
"suggest.snippetsPreventQuickSuggestions": "Controla se um snippet ativo impede sugestões rápidas.",
"suggestFontSize": "Tamanho da fonte do widget de sugestão. Quando definido como `0`, o valor de `#editor.fontSize#` é usado.",
"suggestLineHeight": "Altura da linha do widget de sugestão. Quando definida como `0`, o valor de `#editor.lineHeight#` é usado. O valor mínimo é 8.",
"suggestFontSize": "Tamanho da fonte para o widget sugerido. Quando definido como {0}, o valor de {1} é usado.",
"suggestLineHeight": "Altura da linha para o widget de sugestão. Quando definido como {0}, o valor de {1} é usado. O valor mínimo é 8.",
"suggestOnTriggerCharacters": "Controla se as sugestões devem ser exibidas automaticamente ao digitar caracteres de gatilho.",
"suggestSelection": "Controla como as sugestões são previamente selecionadas ao mostrar a lista de sugestões.",
"suggestSelection.first": "Sempre selecionar a primeira sugestão.",
@ -410,6 +465,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Desabilitar as conclusões da tabulação.",
"tabCompletion.on": "A conclusão da tabulação inserirá a melhor sugestão de correspondência quando você pressionar a tecla Tab.",
"tabCompletion.onlySnippets": "A conclusão da tabulação insere snippets quando o prefixo corresponde. Funciona melhor quando 'quickSuggestions' não está habilitado.",
"tabFocusMode": "Controla se o editor recebe guias ou as transfere para o workbench de navegação.",
"unfoldOnClickAfterEndOfLine": "Controla se clicar no conteúdo vazio depois de uma linha dobrada desdobrará a linha.",
"unicodeHighlight.allowedCharacters": "Define os caracteres permitidos que não estão sendo destacados.",
"unicodeHighlight.allowedLocales": "Caracteres unicode que são comuns em localidades permitidas não estão sendo destacados.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Terminadores de linha incomuns são ignorados.",
"unusualLineTerminators.prompt": "Terminadores de linha incomuns solicitam ser removidos.",
"useTabStops": "A inserção e a exclusão de um espaço em branco seguem as paradas da tabulação.",
"wordBreak": "Controla as regras de quebra de palavras usadas para texto chinês/japonês/coreano (CJK).",
"wordBreak.keepAll": "As quebras de palavras não devem ser usadas para texto chinês/japonês/coreano (CJK). O comportamento do texto não CJK é igual ao normal.",
"wordBreak.normal": "Use a regra de quebra de linha padrão.",
"wordSeparators": "Caracteres que serão usados como separadores de palavras ao fazer operações ou navegações relacionadas a palavras.",
"wordWrap": "Controla como as linhas devem ser quebradas.",
"wordWrap.bounded": "As linhas serão quebradas no mínimo do visor e de `#editor.wordWrapColumn#`.",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "As linhas quebradas obtêm recuo de +1 para o pai.",
"wrappingIndent.none": "Sem recuo. Linhas quebradas começam na coluna 1.",
"wrappingIndent.same": "As linhas quebradas têm o mesmo recuo que o pai.",
"wrappingStrategy": "Controla o algoritmo que computa pontos de quebra de linha.",
"wrappingStrategy": "Controla o algoritmo que calcula os pontos de encapsulamento. Nota que, no modo de acessibilidade, avançado será usado para a melhor experiência.",
"wrappingStrategy.advanced": "Delega a computação do ponto de quebra de linha para o navegador. Este é um algoritmo lento, que pode causar congelamento para arquivos grandes, mas funciona corretamente em todos os casos.",
"wrappingStrategy.simple": "Assume que todos os caracteres têm a mesma largura. Este é um algoritmo rápido que funciona corretamente para fontes com espaçamento uniforme e determinados scripts (como caracteres latinos) em que os glifos têm a mesma largura."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Cor de fundo das guias do par de colchetes inativos (6). Requer a habilitação das guias do par de colchetes.",
"editorCodeLensForeground": "Cor de primeiro plano do editor CodeLens",
"editorCursorBackground": "A cor da tela de fundo do cursor do editor. Permite personalizar a cor de um caractere sobreposto por um cursor de bloco.",
"editorDimmedLineNumber": "Cor da linha final do editor quando editor.renderFinalNewline é definido como esmaecido.",
"editorGhostTextBackground": "Cor da tela de fundo do texto fantasma no editor.",
"editorGhostTextBorder": "Cor da borda de um texto fantasma no editor.",
"editorGhostTextForeground": "Cor de primeiro plano do texto fantasma no editor.",
"editorGutter": "Cor da tela de fundo da medianiz do editor. A medianiz contém as margens do glifo e os números das linhas.",
"editorIndentGuides": "Cor dos guias de recuo do editor.",
"editorLineNumbers": "Cor dos números de linha do editor.",
"editorOverviewRulerBackground": "Cor da tela de fundo da régua de visão geral do editor. Usado somente quando o minimapa está habilitado e colocado no lado direito do editor.",
"editorOverviewRulerBackground": "Cor da tela de fundo da régua de visão geral do editor.",
"editorOverviewRulerBorder": "Cor da borda da régua de visão geral.",
"editorRuler": "Cor das réguas do editor.",
"editorUnicodeHighlight.background": "Cor da tela de fundo usada para realçar os caracteres unicode.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Pressionar Tab no editor atual moverá o foco para o próximo elemento focalizável. No momento, o comando {0} não pode ser disparado por uma associação de teclas.",
"toggleHighContrast": "Ativar/Desativar Tema de Alto Contraste"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} caracteres",
"showMore": "Mostrar mais ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Conjunto de âncoras em {0}:{1}",
"cancelSelectionAnchor": "Cancelar Âncora de Seleção",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Copiar como",
"miCopy": "&&Copiar",
"miCut": "Recor&&tar",
"miPaste": "&&Colar"
"miPaste": "&&Colar",
"share": "Compartilhar"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Ocorreu um erro desconhecido ao aplicar a ação de código"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Ocorreu um erro desconhecido ao aplicar a ação de código",
"args.schema.apply": "Controla quando as ações retornadas são aplicadas.",
"args.schema.apply.first": "Sempre aplicar a primeira ação de código retornada.",
"args.schema.apply.ifSingle": "Aplique a primeira ação de código retornada se ela for a única.",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Organizar as Importações",
"quickfix.trigger.label": "Correção Rápida...",
"refactor.label": "Refatorar...",
"refactor.preview.label": "Refatorar com Visualização...",
"source.label": "Ação de Origem..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Habilitar/desabilitar a exibição de cabeçalhos de grupo no menu de ação de código."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Reescrever...",
"codeAction.widget.id.extract": "Extrair...",
"codeAction.widget.id.inline": "Em linha...",
"codeAction.widget.id.more": "Mais Ações...",
"codeAction.widget.id.move": "Mover...",
"codeAction.widget.id.quickfix": "Correção Rápida...",
"codeAction.widget.id.source": "Ação de Origem...",
"codeAction.widget.id.surround": "Envolver com..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Ocultar Desabilitados",
"showMoreActions": "Mostrar Desabilitado"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Mostrar as Ações do Código",
"codeActionWithKb": "Mostrar as Ações do Código ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "&&Ativar/Desativar o Comentário de Linha"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Mostrar Menu de Contexto do Editor"
"action.showContextMenu.label": "Mostrar Menu de Contexto do Editor",
"context.minimap.minimap": "Minimapa",
"context.minimap.renderCharacters": "Renderizar Caracteres",
"context.minimap.size": "Tamanho vertical",
"context.minimap.size.fill": "Preencher",
"context.minimap.size.fit": "Ajustar",
"context.minimap.size.proportional": "Proporcional",
"context.minimap.slider": "Controle deslizante",
"context.minimap.slider.always": "Sempre",
"context.minimap.slider.mouseover": "Passar o mouse"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Habilitar/desabilitar a execução de edições de extensões ao colar."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Executando manipuladores de pasta..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Refazer Cursor",
"cursor.undo": "Desfazer Cursor"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Executando manipuladores de soltar..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Se o editor executa uma operação que pode ser cancelada, como 'Espiar Referências'"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Substitui o sinalizador \"Caso Matemático\".\r\nO sinalizador não será salvo no futuro.\r\n0: Não Fazer Nada\r\n1: Verdadeiro\r\n2: Falso",
"actions.find.preserveCaseOverride": "Substitui o sinalizador \"Preservar Caso\".\r\nO sinalizador não será salvo no futuro.\r\n0: Não Fazer Nada\r\n1: Verdadeiro\r\n2: Falso",
"actions.find.wholeWordOverride": "Substitui o sinalizador \"Corresponder a Palavra Inteira\".\r\nO sinalizador não será salvo no futuro.\r\n0: Não Fazer Nada\r\n1: Verdadeiro\r\n2: Falso",
"findMatchAction.goToMatch": "Ir para Correspondência...",
"findMatchAction.inputPlaceHolder": "Digite um número para ir para uma correspondência específica (entre 1 e {0})",
"findMatchAction.inputValidationMessage": "Inserir um número entre 1 e {0}",
"findNextMatchAction": "Localizar Próximo",
"findPreviousMatchAction": "Localizar Anterior",
"miFind": "&&Localizar",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Somente os primeiros {0} resultados serão realçados, mas todas as operações de localização funcionarão em todo o texto."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Cor do controle de dobragem na medianiz do editor.",
"createManualFoldRange.label": "Criar Intervalo de Dobramento da Seleção",
"foldAction.label": "Dobrar",
"foldAllAction.label": "Dobrar Tudo",
"foldAllBlockComments.label": "Dobrar Todos os Comentários de Blocos",
"foldAllExcept.label": "Dobrar Todas as Regiões Exceto as Selecionadas",
"foldAllMarkerRegions.label": "Dobrar Todas as Regiões",
"foldBackgroundBackground": "Cor da tela de fundo atrás dos intervalos dobrados. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"foldLevelAction.label": "Nível de Dobra {0}",
"foldRecursivelyAction.label": "Dobrar Recursivamente",
"gotoNextFold.label": "Vá para o Próximo Intervalo Dobrável",
"gotoParentFold.label": "Acessar Dobra Pai",
"gotoPreviousFold.label": "Vá para o Intervalo Dobrável Anterior",
"maximum fold ranges": "O número de regiões dobráveis é limitado a um máximo de {0}. Aumente a opção de configuração ['Dobrando Regiões Máximas'](command:workbench.action.openSettings?[ \"editor.foldingMaximumRegions\"]) para habilitar mais.",
"removeManualFoldingRanges.label": "Remover Intervalos de Dobragem Manual",
"toggleFoldAction.label": "Ativar/Desativar Dobra",
"unFoldRecursivelyAction.label": "Desdobrar Recursivamente",
"unfoldAction.label": "Desdobrar",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Desdobrar Todas as Regiões"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Cor do controle de dobragem na medianiz do editor.",
"foldBackgroundBackground": "Cor da tela de fundo atrás dos intervalos dobrados. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"foldingCollapsedIcon": "Ícone de intervalos recolhidos na margem do glifo do editor.",
"foldingExpandedIcon": "Ícone de intervalos expandidos na margem do glifo do editor."
"foldingExpandedIcon": "Ícone de intervalos expandidos na margem do glifo do editor.",
"foldingManualCollapedIcon": "Ícone para intervalos recolhidos manualmente na margem do glifo do editor.",
"foldingManualExpandedIcon": "Ícone para intervalos recolhidos manualmente na margem do glifo do editor."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Ampliação da Fonte do Editor",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Carregando...",
"stopped rendering": "Renderização pausada por uma linha longa por motivos de desempenho. Isso pode ser configurado por meio de 'editor.stopRenderingLineAfter'.",
"too many characters": "A geração de tokens é ignorada por linhas longas por motivos de desempenho. Isso pode ser configurado por meio de 'editor.maxTokenizationLineLength'."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Exibir o Problema"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Alterar Tamanho de Exibição da Guia",
"configuredTabSize": "Tamanho de Tabulação Configurado",
"currentTabSize": "Tamanho da Guia Atual",
"defaultTabSize": "Tamanho da Guia Padrão",
"detectIndentation": "Detectar Recuo do Conteúdo",
"editor.reindentlines": "Rerecuar Linhas",
"editor.reindentselectedlines": "Rerecuar Linhas Selecionadas",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd + clique"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Aceitar",
"acceptWord": "Aceitar Palavra",
"action.inlineSuggest.accept": "Aceitar Sugestão Embutida",
"action.inlineSuggest.acceptNextWord": "Aceitar a Próxima Palavra de Sugestão Embutida",
"action.inlineSuggest.alwaysShowToolbar": "Sempre Mostrar Barra de Ferramentas",
"action.inlineSuggest.hide": "Ocultar a Sugestão Embutida",
"action.inlineSuggest.showNext": "Mostrar próxima sugestão em linha",
"action.inlineSuggest.showPrevious": "Mostrar sugestões em linha anteriores",
"action.inlineSuggest.trigger": "Disparar sugestão em linha",
"action.inlineSuggest.undo": "Desfazer Aceitar Palavra",
"alwaysShowInlineSuggestionToolbar": "Se a barra de ferramentas de sugestão embutida sempre deve estar visível",
"canUndoInlineSuggestion": "Se desfazer desfaria uma sugestão embutida",
"inlineSuggestionHasIndentation": "Se a sugestão em linha começa com o espaço em branco",
"inlineSuggestionHasIndentationLessThanTabSize": "Se a sugestão embutida começa com um espaço em branco menor do que o que seria inserido pela guia",
"inlineSuggestionVisible": "Se uma sugestão em linha é visível"
"inlineSuggestionVisible": "Se uma sugestão em linha é visível",
"undoAcceptWord": "Desfazer Aceitar Palavra"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Sugestão:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Próximo",
"parameterHintsNextIcon": "Ícone para mostrar a próxima dica de parâmetro.",
"parameterHintsPreviousIcon": "Ícone para mostrar a dica de parâmetro anterior.",
"previous": "Anterior"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Substituir pelo Próximo Valor",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Duplicar Seleção",
"editor.transformToCamelcase": "Transformar-se em Camel Case",
"editor.transformToKebabcase": "Transformar em Caso kebab",
"editor.transformToLowercase": "Transformar em Minúsculas",
"editor.transformToSnakecase": "Transformar em Snake Case",
"editor.transformToTitlecase": "Transformar em Caso de Título",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Executar o comando {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Não é possível editar no editor somente leitura",
"messageVisible": "Se o editor está mostrando uma mensagem embutida no momento"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Mover a Última Seleção para a Correspondência de Localização Anterior",
"mutlicursor.addCursorsToBottom": "Adicionar Cursores na Parte Inferior",
"mutlicursor.addCursorsToTop": "Adicionar Cursores à Parte Superior",
"mutlicursor.focusNextCursor": "Foco no Próximo Cursor",
"mutlicursor.focusNextCursor.description": "Foco no próximo cursor",
"mutlicursor.focusPreviousCursor": "Foco no Cursor Anterior",
"mutlicursor.focusPreviousCursor.description": "Foco no cursor anterior",
"mutlicursor.insertAbove": "Adicionar Cursor Acima",
"mutlicursor.insertAtEndOfEachLineSelected": "Adicionar Cursores nas Extremidades da Linha",
"mutlicursor.insertBelow": "Adicionar Cursor Abaixo",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Cor da tela de fundo da medianiz no editor de modo de exibição de espiada.",
"peekViewEditorMatchHighlight": "Corresponder a cor de realce no editor de modo de exibição de espiada.",
"peekViewEditorMatchHighlightBorder": "Corresponder a borda de realce no editor de modo de exibição de espiada.",
"peekViewEditorStickScrollBackground": "Cor de fundo da rolagem fixa no editor de visualização de inspeção.",
"peekViewResultsBackground": "Cor da tela de fundo da lista de resultados do modo de exibição de espiada.",
"peekViewResultsFileForeground": "Cor de primeiro plano para nós de arquivo na lista de resultados do modo de exibição de espiada.",
"peekViewResultsMatchForeground": "Cor de primeiro plano para nós de linha na lista de resultados do modo de exibição de espiada.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "parâmetros de tipo ({0})",
"variable": "variáveis ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Não é possível editar no editor somente leitura",
"editor.simple.readonly": "Não é possível editar na entrada somente leitura"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "'{0}' foi renomeado com êxito para '{1}'. Resumo: {2}",
"enablePreview": "Habilitar/desabilitar a capacidade de visualizar alterações antes de renomear",
"label": "Renomeando '{0}'",
"label": "Renomeando '{0}' para '{1}'",
"no result": "Nenhum resultado.",
"quotableLabel": "Renomeando {0}",
"quotableLabel": "Renomeando {0} como {1}",
"rename.failed": "A renomeação falhou ao computar edições",
"rename.failedApply": "A renomeação falhou ao aplicar edições",
"rename.label": "Renomear Símbolo",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Se há uma próxima parada de tabulação durante o modo de snippet",
"hasPrevTabstop": "Se há uma parada de tabulação anterior durante o modo de snippet",
"inSnippetMode": "Se o editor atual está no modo de snippet"
"inSnippetMode": "Se o editor atual está no modo de snippet",
"next": "Ir para o próximo espaço reservado..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Abril",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Quarta-feira",
"WednesdayShort": "Qua"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Rolagem Fixa",
"mitoggleStickyScroll": "&&Alternar Rolagem Autoadesiva",
"stickyScroll": "Rolagem Autoadesiva",
"toggleStickyScroll": "Alternar Rolagem Autoadesiva"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Se sugestões são inseridas ao pressionar Enter",
"suggestWidgetDetailsVisible": "Se os detalhes da sugestão estão visíveis",
"suggestWidgetHasSelection": "Se alguma sugestão está focada",
"suggestWidgetMultipleSuggestions": "Se há várias sugestões a serem escolhidas",
"suggestionCanResolve": "Se a sugestão atual dá suporte para resolver mais detalhes",
"suggestionHasInsertAndReplaceRange": "Se a sugestão atual tem os comportamentos inserir e substituir",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Ícone para obter mais informações no widget de sugestão."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "A cor de primeiro plano para símbolos de matriz. Esses símbolos aparecem na estrutura de tópicos, na trilha e no widget de sugestão.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "O arquivo '{0}' contém um ou mais caracteres terminadores de linha incomuns, como Separador de Linha (LS) ou Separador de Parágrafo (PS).\r\n\r\nRecomenda-se removê-los do arquivo. Isto pode ser configurado através do `editor.unusualLineTerminators'.",
"unusualLineTerminators.fix": "Remover Terminadores de Linha Não Usuais",
"unusualLineTerminators.fix": "&&Remover Terminadores de Linha Não Usuais",
"unusualLineTerminators.ignore": "Ignorar",
"unusualLineTerminators.message": "Terminadores de linha incomuns detectados",
"unusualLineTerminators.title": "Terminadores de Linha Incomuns"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Cor do marcador de régua de visão geral para realces de símbolos. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"overviewRulerWordHighlightStrongForeground": "Cor do marcador de régua de visão geral para realces de símbolos de acesso de gravação. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"overviewRulerWordHighlightTextForeground": "Cor do marcador da régua de visão geral de uma ocorrência textual para um símbolo. A cor não deve ser opaca para não esconder as decorações subjacentes.",
"wordHighlight": "Cor da tela de fundo de um símbolo durante o acesso de leitura, como a leitura de uma variável. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"wordHighlight.next.label": "Ir para Próximo Realce do Símbolo",
"wordHighlight.previous.label": "Ir para Realce do Símbolo Anterior",
"wordHighlight.trigger.label": "Disparar Realce do Símbolo",
"wordHighlightBorder": "Cor da borda de um símbolo durante o acesso de leitura, como a leitura de uma variável.",
"wordHighlightStrong": "Cor da tela de fundo de um símbolo durante o acesso de gravação, como gravar em uma variável. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"wordHighlightStrongBorder": "Cor da borda de um símbolo durante o acesso de gravação, como gravar em uma variável."
"wordHighlightStrongBorder": "Cor da borda de um símbolo durante o acesso de gravação, como gravar em uma variável.",
"wordHighlightText": "Cor da tela de fundo de uma ocorrência textual para um símbolo. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"wordHighlightTextBorder": "Cor da borda de uma ocorrência textual para um símbolo."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Ir para Próximo Realce do Símbolo",
"wordHighlight.previous.label": "Ir para Realce do Símbolo Anterior",
"wordHighlight.trigger.label": "Disparar Realce do Símbolo"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Excluir Palavra"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Desenvolvedor",
"help": "Ajuda",
"preferences": "Preferências",
"test": "Testar",
"view": "Exibir"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Ocultar",
"resetThisMenu": "Redefinir Menu"
},
"vs/platform/actions/common/menuService": {
"hide.label": "Ocultar '{0}'"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Widget de Ação",
"customQuickFixWidget.labels": "{0}, Motivo desabilitado: {1}",
"label": "{0} para se inscrever",
"label-preview": "{0} para aplicar, {1} para exibir"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Aceitar ação selecionada",
"codeActionMenuVisible": "Se a lista de widgets de ação está visível",
"hideCodeActionWidget.title": "Ocultar widget de ação",
"previewSelected.title": "Visualizar a ação selecionada",
"selectNextCodeAction.title": "Selecionar a próxima ação",
"selectPrevCodeAction.title": "Selecionar ação anterior"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Linha de Comparação Excluída",
"audioCues.diffLineInserted": "Linha de Comparação Inserida",
"audioCues.diffLineModified": "Linha Diferenciada Modificada",
"audioCues.lineHasBreakpoint.name": "Ponto de interrupção na linha",
"audioCues.lineHasError.name": "Erro na linha",
"audioCues.lineHasFoldedArea.name": "Área Dobrada em Linha",
"audioCues.lineHasInlineSuggestion.name": "Sugestão em Linha",
"audioCues.lineHasWarning.name": "Aviso em linha",
"audioCues.noInlayHints": "Sem Dicas de Embutimento na Linha",
"audioCues.notebookCellCompleted": "Célula do Notebook Concluída",
"audioCues.notebookCellFailed": "Falha na Célula do Notebook",
"audioCues.onDebugBreak.name": "Depurador Parado no Ponto de Interrupção",
"audioCues.taskCompleted": "Tarefa Concluída",
"audioCues.taskFailed": "Falha na Tarefa",
"audioCues.terminalBell": "Sino do Terminal",
"audioCues.terminalCommandFailed": "Falha no Comando da Terminal",
"audioCues.terminalQuickFix.name": "Correção Rápida do Terminal"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "Não é possível registrar '{0}'. A política associada {1} já está registrada com {2}.",
"config.property.duplicate": "Não é possível registrar '{0}'. Esta propriedade já está registrada.",
"config.property.empty": "Não é possível registrar uma propriedade vazia",
"config.property.languageDefault": "Não é possível registrar '{0}'. Isso corresponde ao padrão de propriedade '\\\\[.*\\\\]$' para descrever as configurações de editor específicas da linguagem. Use a contribuição 'configurationDefaults'.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Se o sistema operacional é Linux",
"isMac": "Se o sistema operacional é macOS",
"isMacNative": "Se o sistema operacional é macOS em uma plataforma que não é de navegador",
"isMobile": "Se a plataforma é um navegador da web móvel",
"isWeb": "Se a plataforma é um navegador da Web",
"isWindows": "Se o sistema operacional é Windows"
"isWindows": "Se o sistema operacional é Windows",
"productQualityType": "Tipo de qualidade de VS Code"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Cancelar",
"moreFile": "...1 arquivo adicional não mostrado",
"moreFiles": "...{0} arquivos adicionais não mostrados"
"moreFiles": "...{0} arquivos adicionais não mostrados",
"okButton": "&&OK",
"yesButton": "&&Sim"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "O arquivo é muito grande para ser aberto como editor sem título. Carregue-o primeiro no explorador de arquivos e tente novamente."
},
"vs/platform/files/common/files": {
"sizeB": "{0} B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Multiplicador de velocidade de rolagem ao pressionar `Alt`.",
"Mouse Wheel Scroll Sensitivity": "Um multiplicador a ser usado no `deltaX` e no `deltaY` dos eventos de rolagem do mouse.",
"automatic keyboard navigation setting": "Controla se a navegação pelo teclado em listas e árvores é disparada automaticamente ao digitar. Se definida como `false`, a navegação pelo teclado é disparada apenas ao executar o comando `list.toggleKeyboardNavigation`, ao qual você pode atribuir um atalho de teclado.",
"defaultFindMatchTypeSettingKey": "Controla o tipo de correspondência usado ao pesquisar listas e árvores no workbench.",
"defaultFindMatchTypeSettingKey.contiguous": "Use correspondência contígua ao pesquisar.",
"defaultFindMatchTypeSettingKey.fuzzy": "Use correspondência difusa ao pesquisar.",
"defaultFindModeSettingKey": "Controla o modo de localização padrão para listas e árvores no workbench.",
"defaultFindModeSettingKey.filter": "Filtrar elementos ao pesquisar.",
"defaultFindModeSettingKey.highlight": "Realce os elementos ao pesquisar. Mais para cima e para baixo, a navegação atravessará apenas os elementos realçados.",
"expand mode": "Controla como as pastas de árvore são expandidas ao clicar nos nomes das pastas. Observe que algumas árvores e listas poderão optar por ignorar essa configuração se ela não for aplicável.",
"horizontalScrolling setting": "Controla se as listas e árvores dão suporte à rolagem horizontal no workbench. Aviso: a ativação desta configuração tem uma implicação de desempenho.",
"keyboardNavigationSettingKey": "Controla o estilo de navegação pelo teclado para listas e árvores no workbench. Pode ser simples, realçar e filtrar.",
"keyboardNavigationSettingKey.filter": "Filtrar a navegação pelo teclado filtrará e ocultará todos os elementos que não correspondem à entrada do teclado.",
"keyboardNavigationSettingKey.highlight": "Realçar a navegação pelo teclado realça elementos que correspondem à entrada do teclado. A navegação mais acima e abaixo passará apenas pelos elementos realçados.",
"keyboardNavigationSettingKey.simple": "A navegação pelo teclado simples tem como foco elementos que correspondem à entrada do teclado. A correspondência é feita somente em prefixos.",
"keyboardNavigationSettingKeyDeprecated": "Em vez disso, use 'workbench.list.defaultFindMode' e 'workbench.list.typeNavigationMode'.",
"list smoothScrolling setting": "Controla se listas e árvores têm rolagem suave.",
"list.scrollByPage": "Controla se os cliques na barra de rolagem rolam página por página.",
"multiSelectModifier": "O modificador a ser usado para adicionar um item em árvores e listas a uma seleção múltipla com o mouse (por exemplo, no explorador, abra os editores e a exibição de scm). Os gestos de mouse 'Abrir ao Lado', se compatíveis, se adaptarão de modo que não entrarão em conflito com o modificador de seleção múltipla.",
"multiSelectModifier.alt": "Mapeia para `Alt` no Windows e no Linux e para `Option` no macOS.",
"multiSelectModifier.ctrlCmd": "Mapeia para `Control` no Windows e no Linux e para `Command` no macOS.",
"openModeModifier": "Controla como abrir itens em árvores e listas usando o mouse (caso haja suporte). Observe que algumas árvores e listas podem optar por ignorar essa configuração quando ela não se aplica.",
"render tree indent guides": "Controla se a árvore deve renderizar guias de recuo.",
"tree indent setting": "Controle o recuo da árvore em pixels.",
"typeNavigationMode": "Controla como a navegação de tipos funciona em listas e árvores no workbench. Quando definido como 'trigger', a navegação de tipo começa assim que o comando 'list.triggerTypeNavigation' é executado.",
"workbenchConfigurationTitle": "Workbench"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Aviso"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "O comando '{0}' resultou em um erro ({1})",
"canNotRun": "O comando \"{0}\" resultou em um erro",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "comumente usado",
"morecCommands": "outros comandos",
"recentlyUsed": "usado recentemente"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "comandos do editor",
"globalCommands": "comandos globais",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Personalizado",
"inputModeEntry": "Pressione 'Enter' para confirmar sua entrada ou 'Escape' para cancelar",
"inputModeEntryDescription": "{0} (Pressione 'Enter' para confirmar ou 'Escape' para cancelar)",
"ok": "OK",
"quickInput.back": "Voltar",
"quickInput.backWithKeybinding": "Voltar ({0})",
"quickInput.checkAll": "Alternar todas as caixas de seleção",
"quickInput.countSelected": "{0} Selecionados",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} Resultados",
"quickInputBox.ariaLabel": "Digite para restringir os resultados."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Entrada Rápida"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Clique para executar o comando '{0}'"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Uma borda extra em torno dos elementos ativos para separá-los de outros para maior contraste.",
"activeLinkForeground": "Cor dos links ativos.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Cor da tela de fundo dos itens de trilha.",
"breadcrumbsFocusForeground": "Cor dos itens de trilha com foco.",
"breadcrumbsSelectedBackground": "Cor da tela de fundo do seletor de item de trilha.",
"breadcrumbsSelectedForegound": "Cor dos itens de trilha selecionados.",
"breadcrumbsSelectedForeground": "Cor dos itens de trilha selecionados.",
"buttonBackground": "Cor da tela de fundo do botão.",
"buttonBorder": "Cor da borda do botão.",
"buttonForeground": "Cor de primeiro plano do botão.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Cor da tela de fundo do botão secundário.",
"buttonSecondaryForeground": "Cor de primeiro plano do botão secundário.",
"buttonSecondaryHoverBackground": "Cor da tela de fundo do botão secundário ao passar o mouse.",
"buttonSeparator": "Cor do separador de botão.",
"chartsBlue": "A cor azul usada nas visualizações do gráfico.",
"chartsForeground": "A cor de primeiro plano usada em gráficos.",
"chartsGreen": "A cor verde usada nas visualizações do gráfico.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Cor da tela de fundo do widget de caixa de seleção.",
"checkbox.border": "Cor da borda do widget de caixa de seleção.",
"checkbox.foreground": "Cor de primeiro plano do widget de caixa de seleção.",
"checkbox.select.background": "Cor da tela de fundo do widget da caixa de seleção quando o elemento em que ele está é selecionado.",
"checkbox.select.border": "Cor da borda do widget da caixa de seleção quando o elemento em que ele está é selecionado.",
"contrastBorder": "Uma borda extra em torno dos elementos para separá-los de outros para maior contraste.",
"descriptionForeground": "Cor de primeiro plano para texto de descrição fornecendo informações adicionais, por exemplo, para um rótulo.",
"diffDiagonalFill": "Cor do preenchimento diagonal do editor de comparação. O preenchimento diagonal é usado em modos de exibição de comparação lado a lado.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Cor de fundo para a margem onde as linhas foram removidas.",
"diffEditorRemovedLines": "Cor de fundo para linhas que foram removidas. A cor não deve ser opaca para não esconder as decorações subjacentes.",
"diffEditorRemovedOutline": "Cor da estrutura de tópicos do texto que foi removido.",
"disabledForeground": "Primeiro plano geral para elementos desabilitados. Essa cor somente é usada se não for substituída por um componente.",
"dropdownBackground": "Tela de fundo suspensa.",
"dropdownBorder": "Borda suspensa.",
"dropdownForeground": "Primeiro plano suspenso.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Cor do texto selecionado para alto contraste.",
"editorSelectionHighlight": "Cor para regiões com o mesmo conteúdo da seleção. A cor não deve ser opaca para não ocultar decorações subjacentes.",
"editorSelectionHighlightBorder": "Cor da borda para regiões com o mesmo conteúdo da seleção.",
"editorStickyScrollBackground": "Cor da tela de fundo de rolagem autoadesiva para o editor",
"editorStickyScrollHoverBackground": "Rolagem autoadesiva na cor da tela de fundo do foco para o editor",
"editorWarning.background": "A cor da tela de fundo do texto do aviso no editor. A cor não pode ser opaca para não ocultar as decorações subjacentes.",
"editorWarning.foreground": "Cor de primeiro plano das linhas sinuosas de aviso no editor.",
"editorWidgetBackground": "Cor da tela de fundo dos widgets do editor, como localizar/substituir.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Cor da tela de fundo do widget de filtro de tipo em listas e árvores.",
"listFilterWidgetNoMatchesOutline": "Cor da estrutura de tópicos do widget de filtro de tipo em listas e árvores, quando não há correspondências.",
"listFilterWidgetOutline": "Cor da estrutura de tópicos do widget de filtro de tipo em listas e árvores.",
"listFilterWidgetShadow": "Cor da sombra do widget de filtro de tipo nas listas e árvores.",
"listFocusAndSelectionOutline": "Cor do contorno da lista/árvore para o item em foco quando a lista/árvore está ativa e selecionada. Uma lista/árvore ativa tem foco no teclado, um inativo não.",
"listFocusBackground": "Cor da tela de fundo da lista/árvore para o item com foco quando a lista/árvore estiver ativa. Uma lista/árvore ativa tem o foco do teclado, uma inativa não.",
"listFocusForeground": "Cor de primeiro plano da lista/árvore para o item focalizado quando a lista/árvore estiver ativa. Uma lista/árvore ativa tem o foco do teclado, uma inativa não.",
"listFocusHighlightForeground": "A cor de primeiro plano Lista/Árvore da combinação é realçada nos itens com foco ativo durante a pesquisa dentro da lista/árvore.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Plano de fundo da barra de ferramentas ao manter o mouse sobre as ações",
"toolbarHoverBackground": "Plano de fundo da barra de ferramentas ao passar o mouse sobre as ações",
"toolbarHoverOutline": "Contorno da barra de ferramentas ao passar o mouse sobre as ações com o mouse",
"treeInactiveIndentGuidesStroke": "Cor do traço de árvore para as guias de recuo que não estão ativas.",
"treeIndentGuidesStroke": "Cor do traço da árvore dos guias de recuo.",
"warningBorder": "Cor da borda das caixas de aviso no editor.",
"widgetBorder": "Cor da sombra de widgets, como localizar/substituir, dentro do editor.",
"widgetShadow": "Cor da sombra de widgets, como localizar/substituir, dentro do editor."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Ícone da ação fechar nos widgets."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Cancelar",
"cannotResourceRedoDueToInProgressUndoRedo": "Não foi possível refazer '{0}' porque já há uma operação de desfazer ou refazer em execução.",
"cannotResourceUndoDueToInProgressUndoRedo": "Não foi possível desfazer '{0}' porque já há uma operação de desfazer ou refazer em execução.",
"cannotWorkspaceRedo": "Não foi possível refazer '{0}' em todos os arquivos. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "Não foi possível desfazer '{0}' em todos os arquivos porque já há uma operação de desfazer ou refazer em execução em {1}",
"confirmDifferentSource": "Deseja desfazer '{0}'?",
"confirmDifferentSource.no": "Não",
"confirmDifferentSource.yes": "Sim",
"confirmDifferentSource.yes": "&&Sim",
"confirmWorkspace": "Deseja desfazer '{0}' em todos os arquivos?",
"externalRemoval": "Os seguintes arquivos foram fechados e modificados no disco: {0}.",
"noParallelUniverses": "Os seguintes arquivos foram modificados de modo incompatível: {0}.",
"nok": "Desfazer este Arquivo",
"ok": "Desfazer em {0} Arquivos"
"nok": "Desfazer este &&Arquivo",
"ok": "&&Desfazer em {0} Arquivos"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Workspace do Código"

2910
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/qps-ploc.js vendored
View File

File diff suppressed because it is too large Load Diff

400
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/ru.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Дополнительные действия..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "Закрыть диалоговое окно",
"dialogErrorMessage": "Ошибка",
"dialogInfoMessage": "Информация",
"dialogPendingMessage": "Выполняется.",
"dialogWarningMessage": "Предупреждение.",
"ok": "OK"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Дополнительные действия..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "входные данные"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "С учетом регистра",
"regexDescription": "Использовать регулярное выражение",
"wordsDescription": "Слово целиком"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "входные данные",
"label.preserveCaseToggle": "Сохранить регистр"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "свободный"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Поле выбора"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Дополнительные действия..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Сброс",
"disable filter on type": "Отключить фильтр по типу",
"empty": "Элементы не найдены",
"enable filter on type": "Включить фильтр по типу",
"found": "Сопоставлено элементов: {0} из {1}"
"close": "Закрыть",
"filter": "Фильтр",
"fuzzySearch": "Нечеткое совпадение",
"not found": "Элементы не найдены.",
"type to filter": "Введите текст для фильтра",
"type to search": "Ввод для поиска"
},
"vs/base/common/actions": {
"submenu.empty": "(пусто)"
@ -49,25 +75,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"optKey.long": "Параметр",
"shiftKey": "SHIFT",
"shiftKey.long": "SHIFT",
"superKey": "Превосходно",
"superKey.long": "Превосходно",
"superKey": "Super",
"superKey.long": "Super",
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Другой",
"inputModeEntry": "Нажмите клавишу ВВОД, чтобы подтвердить введенные данные, или ESCAPE для отмены",
"inputModeEntryDescription": "{0} (нажмите клавишу ВВОД, чтобы подтвердить введенные данные, или ESCAPE для отмены)",
"ok": "OK",
"quickInput.back": "Назад",
"quickInput.backWithKeybinding": "Назад ({0})",
"quickInput.countSelected": "{0} выбрано",
"quickInput.steps": "{0} / {1}",
"quickInput.visibleCount": "Результаты: {0}",
"quickInputBox.ariaLabel": "Введите текст, чтобы уменьшить число результатов."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Быстрый ввод"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "Сейчас редактор недоступен. Нажмите {0} для отображения вариантов.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Отменить"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "Количество курсоров ограничено {0}."
"cursors.maximum": "Число курсоров ограничено {0}. Для проведения крупных изменений рекомендуется использовать [поиск и замену](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) или увеличить значение параметра ограничения нескольких курсоров в редакторе.",
"goToSetting": "Увеличить значение ограничения нескольких курсоров"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " используйте SHIFT + F7 для навигации по изменениям",
"diff.tooLarge": "Нельзя сравнить файлы, потому что один из файлов слишком большой.",
"diffInsertIcon": "Оформление строки для вставок в редакторе несовпадений.",
"diffRemoveIcon": "Оформление строки для удалений в редакторе несовпадений."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Определяет, отображается ли CodeLens в редакторе.",
"detectIndentation": "Управляет тем, будут ли параметры \"#editor.tabSize#\" и \"#editor.insertSpaces#\" определяться автоматически при открытии файла на основе содержимого файла.",
"detectIndentation": "На основе содержимого файла определяет, будут ли {0} и {1} автоматически обнаружены при открытии файла.",
"diffAlgorithm.experimental": "Использует экспериментальный алгоритм сравнения.",
"diffAlgorithm.smart": "Использует алгоритм сравнения по умолчанию.",
"editor.experimental.asyncTokenization": "Определяет, должна ли разметка происходить асинхронно в рабочей роли.",
"editorConfigurationTitle": "Редактор",
"ignoreTrimWhitespace": "Когда параметр включен, редактор несовпадений игнорирует изменения начального или конечного пробела.",
"insertSpaces": "Вставлять пробелы при нажатии клавиши TAB. Этот параметр переопределяется на основе содержимого файла, если установлен параметр \"#editor.detectIndentation#\". ",
"indentSize": "Число пробелов, используемых для отступа, либо `\"tabSize\"` для использования значения из \"#editor.tabSize#\". Этот параметр переопределяется на основе содержимого файла, если включен параметр \"#editor.detectIndentation#\".",
"insertSpaces": "Вставлять пробелы при нажатии клавиши TAB. Этот параметр переопределяется на основе содержимого файла, если включен параметр {0}.",
"largeFileOptimizations": "Специальная обработка для больших файлов с отключением некоторых функций, которые интенсивно используют память.",
"maxComputationTime": "Время ожидания в миллисекундах, по истечении которого вычисление несовпадений отменяется. Укажите значение 0, чтобы не использовать время ожидания.",
"maxFileSize": "Максимальный размер файла в МБ для вычисления различий. Используйте 0 без ограничений.",
"maxTokenizationLineLength": "Строки, длина которых превышает указанное значение, не будут размечены из соображений производительности",
"renderIndicators": "Определяет, должны ли в редакторе отображаться индикаторы +/- для добавленных или удаленных изменений.",
"renderMarginRevertIcon": "Если этот параметр включен, в редакторе несовпадений на поле глифа отображаются стрелки для отмены изменений.",
"schema.brackets": "Определяет символы скобок, увеличивающие или уменьшающие отступ.",
"schema.closeBracket": "Закрывающий символ скобки или строковая последовательность.",
"schema.colorizedBracketPairs": "Определяет пары скобок, цвет которых зависит от их уровня вложения, если включена опция выделения цветом.",
@ -140,14 +161,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.true": "Семантическое выделение включено для всех цветовых тем.",
"sideBySide": "Определяет, как редактор несовпадений отображает отличия: рядом или в тексте.",
"stablePeek": "Оставлять быстрый редактор открытым даже при двойном щелчке по его содержимому и при нажатии ESC.",
"tabSize": "Число пробелов в табуляции. Этот параметр переопределяется на основе содержимого файла, если установлен параметр \"#editor.detectIndentation#\".",
"tabSize": "Число пробелов, соответствующее табуляции. Этот параметр переопределяется на основе содержимого файла, если включен параметр {0}.",
"trimAutoWhitespace": "Удалить автоматически вставляемый конечный пробел.",
"wordBasedSuggestions": "Определяет, следует ли оценивать завершения на основе слов в документе.",
"wordBasedSuggestionsMode": "Определяет, из каких документов будут вычисляться завершения на основе слов.",
"wordBasedSuggestionsMode.allDocuments": "Предложение слов из всех открытых документов.",
"wordBasedSuggestionsMode.currentDocument": "Предложение слов только из активного документа.",
"wordBasedSuggestionsMode.matchingDocuments": "Предложение слов из всех открытых документов на одном языке.",
"wordWrap.inherit": "Строки будут переноситься в соответствии с параметром \"#editor.wordWrap#\".",
"wordWrap.inherit": "Строки будут переноситься в соответствии с настройкой {0}.",
"wordWrap.off": "Строки не будут переноситься никогда.",
"wordWrap.on": "Строки будут переноситься по ширине окна просмотра."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "Определяет, будут ли предложения приниматься клавишей ВВОД в дополнение к клавише TAB. Это помогает избежать неоднозначности между вставкой новых строк и принятием предложений.",
"acceptSuggestionOnEnterSmart": "Принимать предложение при нажатии клавиши ВВОД только в том случае, если оно изменяет текст.",
"accessibilityPageSize": "Управляет числом строк в редакторе, которые могут быть прочитаны средством чтения с экрана за один раз. При обнаружении средства чтения с экрана автоматически устанавливается значение по умолчанию 500. Внимание! При указании числа строк, превышающего значение по умолчанию, возможно снижение производительности.",
"accessibilitySupport": "Определяет, следует ли запустить редактор в режиме оптимизации для средства чтения с экрана. Если параметр включен, перенос строк будет отключен.",
"accessibilitySupport.auto": "Редактор будет определять, подключено ли средство чтения с экрана, с помощью API-интерфейсов платформы.",
"accessibilitySupport.off": "Редактор никогда не будет оптимизироваться для использования со средством чтения с экрана.",
"accessibilitySupport.on": "Редактор будет оптимизирован для использования со средством чтения с экрана в постоянном режиме. Перенос текста будет отключен.",
"accessibilitySupport": "Определяет, следует ли запустить пользовательский интерфейс в режиме оптимизации для средства чтения с экрана.",
"accessibilitySupport.auto": "Использовать API-интерфейсы платформы, чтобы определять, подключено ли средство чтения с экрана",
"accessibilitySupport.off": "Предполагать, что средство чтения с экрана не подключено",
"accessibilitySupport.on": "Оптимизировать для использования со средством чтения с экрана",
"alternativeDeclarationCommand": "Идентификатор альтернативный команды, выполняемой в том случае, когда результатом операции \"Перейти к объявлению\" является текущее расположение.",
"alternativeDefinitionCommand": "Идентификатор альтернативной команды, выполняемой в том случае, когда результатом операции \"Перейти к определению\" является текущее расположение.",
"alternativeImplementationCommand": "Идентификатор альтернативный команды, выполняемой, когда результатом команды \"Перейти к реализации\" является текущее расположение.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Определяет, должен ли редактор автоматически закрывать кавычки, если пользователь добавил открывающую кавычку.",
"autoIndent": "Определяет, должен ли редактор автоматически изменять отступы, когда пользователи вводят, вставляют или перемещают текст или изменяют отступы строк.",
"autoSurround": "Определяет, должен ли редактор автоматически обрамлять выделения при вводе кавычек или квадратных скобок.",
"bracketPairColorization.enabled": "Активирует раскраску парных скобок. Переопределить цвета выделения скобок можно с помощью \\\"#workbench.colorCustomizations#\\\".",
"bracketPairColorization.enabled": "Определяет, включена ли раскраска пар скобок. Используйте {0} для переопределения цветов выделения скобок.",
"bracketPairColorization.independentColorPoolPerBracketType": "Определяет, имеет ли каждый тип скобок собственный независимый пул цветов.",
"codeActions": "Включает индикатор действия кода в редакторе.",
"codeActions": "Включает значок лампочки для действия кода в редакторе.",
"codeLens": "Определяет, отображается ли CodeLens в редакторе.",
"codeLensFontFamily": "Управляет семейством шрифтов для CodeLens.",
"codeLensFontSize": "Определяет размер шрифта в пикселях для CodeLens. Если задано значение \"0\", то используется 90 % от размера \"#editor.fontSize#\".",
"codeLensFontSize": "Определяет размер шрифта в пикселях для CodeLens. Если задано значение 0, то используется 90% от размера #editor.fontSize#.",
"colorDecorators": "Определяет, должны ли в редакторе отображаться внутренние декораторы цвета и средство выбора цвета.",
"colorDecoratorsLimit": "Управляет максимальным количеством цветовых декораторов, которые можно отрисовать в редакторе одновременно.",
"columnSelection": "Включение того, что выбор с помощью клавиатуры и мыши приводит к выбору столбца.",
"comments.ignoreEmptyLines": "Определяет, должны ли пустые строки игнорироваться с помощью действий переключения, добавления или удаления для комментариев к строкам.",
"comments.insertSpace": "Определяет, вставляется ли пробел при комментировании.",
"copyWithSyntaxHighlighting": "Определяет, будет ли текст скопирован в буфер обмена с подсветкой синтаксиса.",
"cursorBlinking": "Управляет стилем анимации курсора.",
"cursorSmoothCaretAnimation": "Управляет тем, следует ли включить плавную анимацию курсора.",
"cursorSmoothCaretAnimation.explicit": "Плавная анимация курсора включена, только если пользователь перемещает курсор явным жестом.",
"cursorSmoothCaretAnimation.off": "Плавная анимация курсора отключена.",
"cursorSmoothCaretAnimation.on": "Плавная анимация курсора всегда включена.",
"cursorStyle": "Управляет стилем курсора.",
"cursorSurroundingLines": "Определяет минимальное число видимых начальных и конечных линий, окружающих курсор. Этот параметр имеет название \"scrollOff\" или \"scrollOffset\" в некоторых других редакторах.",
"cursorSurroundingLines": "Определяет минимальное число видимых начальных линий (минимум 0) и конечных линий (минимум 1), окружающих курсор. Этот параметр имеет название \"scrollOff\" или \"scrollOffset\" в некоторых других редакторах.",
"cursorSurroundingLinesStyle": "Определяет, когда необходимо применять \"cursorSurroundingLines\".",
"cursorSurroundingLinesStyle.all": "\"cursorSurroundingLines\" принудительно применяется во всех случаях.",
"cursorSurroundingLinesStyle.default": "\"cursorSurroundingLines\" применяется только при запуске с помощью клавиатуры или API.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Определяет, всегда ли жест мышью для перехода к определению открывает мини-приложение быстрого редактирования.",
"deprecated": "Этот параметр устарел. Используйте вместо него отдельные параметры, например, 'editor.suggest.showKeywords' или 'editor.suggest.showSnippets'.",
"dragAndDrop": "Определяет, следует ли редактору разрешить перемещение выделенных элементов с помощью перетаскивания.",
"dropIntoEditor.enabled": "Определяет, можно ли перетаскивать файл в редактор, удерживая нажатой клавишу SHIFT (вместо открытия файла в самом редакторе).",
"editor.autoClosingBrackets.beforeWhitespace": "Автоматически закрывать скобки только в том случае, если курсор находится слева от пробела.",
"editor.autoClosingBrackets.languageDefined": "Использовать конфигурации языка для автоматического закрытия скобок.",
"editor.autoClosingDelete.auto": "Удалять соседние закрывающие кавычки и квадратные скобки только в том случае, если они были вставлены автоматически.",
@ -219,7 +245,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.find.seedSearchStringFromSelection.never": "Никогда не вставлять начальные значения в строку поиска из выделенного фрагмента редактора.",
"editor.find.seedSearchStringFromSelection.selection": "Вставлять начальные значения в строку поиска только из выделенного фрагмента редактора.",
"editor.gotoLocation.multiple.deprecated": "Этот параметр устарел. Используйте вместо него отдельные параметры, например, 'editor.editor.gotoLocation.multipleDefinitions' или 'editor.editor.gotoLocation.multipleImplementations'.",
"editor.gotoLocation.multiple.goto": "Перейдите к основному результату и включите быструю навигацию для остальных",
"editor.gotoLocation.multiple.goto": "Перейти к основному результату и включить быструю навигацию для остальных",
"editor.gotoLocation.multiple.gotoAndPeek": "Перейти к основному результату и показать быстрый редактор",
"editor.gotoLocation.multiple.peek": "Показать предварительные результаты (по умолчанию)",
"editor.guides.bracketPairs": "Определяет, включены ли направляющие пар скобок.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Включение горизонтальных направляющих в дополнение к вертикальным направляющим для пар скобок.",
"editor.guides.highlightActiveBracketPair": "Управляет тем, должна ли выделяться активная пара квадратных скобок в редакторе.",
"editor.guides.highlightActiveIndentation": "Управляет тем, должна ли выделяться активная направляющая отступа в редакторе.",
"editor.guides.highlightActiveIndentation.always": "Выделяет активную направляющую отступа, даже если выделены направляющие скобок.",
"editor.guides.highlightActiveIndentation.false": "Не выделять активную направляющую отступа.",
"editor.guides.highlightActiveIndentation.true": "Выделяет активную направляющую отступа.",
"editor.guides.indentation": "Определяет, должны ли в редакторе отображаться направляющие отступа.",
"editor.inlayHints.off": "Вложенные подсказки отключены.",
"editor.inlayHints.offUnlessPressed": "Вложенные подсказки по умолчанию скрыты и отображаются при удержании {0}.",
"editor.inlayHints.on": "Вложенные подсказки включены.",
"editor.inlayHints.onUnlessPressed": "Вложенные подсказки отображаются по умолчанию и скрываются удержанием клавиш {0}.",
"editor.stickyScroll": "Отображает вложенные текущие области во время прокрутки в верхней части редактора.",
"editor.stickyScroll.": "Определяет максимальное число залипающих линий для отображения.",
"editor.suggest.matchOnWordStartOnly": "При включении фильтрации IntelliSense необходимо, чтобы первый символ совпадал в начале слова, например \"c\" в \"Console\" или \"WebContext\", но _не_ в \"description\". Если параметр отключен, IntelliSense отображает больше результатов, но по-прежнему сортирует их по качеству соответствия.",
"editor.suggest.showClasss": "Когда параметр включен, в IntelliSense отображаются предложения \"class\".",
"editor.suggest.showColors": "Когда параметр включен, в IntelliSense отображаются предложения \"color\".",
"editor.suggest.showConstants": "Когда параметр включен, в IntelliSense отображаются предложения \"constant\".",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Когда параметр включен, в IntelliSense отображаются предложения \"variable\".",
"editorViewAccessibleLabel": "Содержимое редактора",
"emptySelectionClipboard": "Управляет тем, копируется ли текущая строка при копировании без выделения.",
"experimentalWhitespaceRendering": "Определяет, отрисовывается ли пробел с использованием нового экспериментального метода.",
"experimentalWhitespaceRendering.font": "Использовать новый метод отрисовки с символами шрифта.",
"experimentalWhitespaceRendering.off": "Использовать стабильный метод отрисовки.",
"experimentalWhitespaceRendering.svg": "Использовать новый метод отрисовки с SVG.",
"fastScrollSensitivity": "Коэффициент увеличения скорости прокрутки при нажатии клавиши ALT.",
"find.addExtraSpaceOnTop": "Определяет, должно ли мини-приложение поиска добавлять дополнительные строки в начале окна редактора. Если задано значение true, вы можете прокрутить первую строку при отображаемом мини-приложении поиска.",
"find.autoFindInSelection": "Управляет условием автоматического включения функции «Найти в выделении».",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Включает или отключает лигатуры шрифтов (характеристики шрифта \"calt\" и \"liga\"). Измените этот параметр на строку для детального управления свойством CSS \"font-feature-settings\".",
"fontLigaturesGeneral": "Настраивает лигатуры или характеристики шрифта. Можно указать логическое значение, чтобы включить или отключить лигатуры, или строку для значения свойства CSS \"font-feature-settings\".",
"fontSize": "Определяет размер шрифта в пикселях.",
"fontVariationSettings": "Явное свойство CSS font-variation-settings. Если необходимо лишь преобразовать параметр font-weight в параметр font-variation-settings, вместо этого свойства можно передать логическое значение.",
"fontVariations": "Включает или отключает преобразование из параметра font-weight в font-variation-settings. Измените этот параметр на строку для детального управления свойством CSS font-variation-settings.",
"fontVariationsGeneral": "Настраивает варианты шрифтов. Может представлять собой логическое значение для включения или отключения преобразования из параметра font-weight в параметр font-variation-settings или строку, содержащую значение свойства CSS font-variation-settings.",
"fontWeight": "Управляет насыщенностью шрифта. Допустимые значения: ключевые слова \"normal\" или \"bold\", а также числа в диапазоне от 1 до 1000.",
"fontWeightErrorMessage": "Допускаются только ключевые слова \"normal\" или \"bold\" и числа в диапазоне от 1 до 1000.",
"formatOnPaste": "Определяет, будет ли редактор автоматически форматировать вставленное содержимое. Модуль форматирования должен быть доступен и иметь возможность форматировать диапазон в документе.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Управляет тем, отображается ли наведение.",
"hover.sticky": "Управляет тем, должно ли наведение оставаться видимым при наведении на него курсора мыши.",
"inlayHints.enable": "Включает встроенные указания в редакторе.",
"inlayHints.fontFamily": "Определяет семейство шрифтов для указаний-вкладок в редакторе. Если никакое значение не задано, используется `#editor.fontFamily#`.",
"inlayHints.fontSize": "Управляет размером шрифта вложенных указаний в редакторе. Значение по умолчанию 90% \"#editor.fontSize#\" используется, если заданное значение меньше \"5\" или больше размера шрифта редактора.",
"inlayHints.fontFamily": "Управляет семейством шрифтов для вложенных подсказок в редакторе. Если значение не задано, используется {0}.",
"inlayHints.fontSize": "Управляет размером шрифта вложенных подсказок в редакторе. По умолчанию {0} используется, когда сконфигурированное значение меньше {1} или больше размера шрифта редактора.",
"inlayHints.padding": "Включает поля вокруг встроенных указаний в редакторе.",
"inline": "Экспресс-предложения отображаются как едва различимый текст",
"inlineSuggest.enabled": "Определяет, следует ли автоматически показывать встроенные предложения в редакторе.",
"inlineSuggest.showToolbar": "Определяет, когда отображать встроенную панель инструментов предложений.",
"inlineSuggest.showToolbar.always": "Отображать панель инструментов встроенного предложения при каждом отображении встроенного предложения.",
"inlineSuggest.showToolbar.onHover": "Отображать панель инструментов предложений при наведении указателя мыши на встроенное предложение.",
"letterSpacing": "Управляет интервалом между буквами в пикселях.",
"lineHeight": "Определяет высоту строки. \r\n– Используйте 0, чтобы автоматически вычислить высоту строки на основе размера шрифта.\r\n– Значения от 0 до 8 будут использоваться в качестве множителя для размера шрифта.\r\n– Значения больше или равные 8 будут использоваться в качестве действующих значений.",
"lineNumbers": "Управляет отображением номеров строк.",
@ -305,9 +352,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"lineNumbers.off": "Номера строк не отображаются.",
"lineNumbers.on": "Отображаются абсолютные номера строк.",
"lineNumbers.relative": "Отображаемые номера строк вычисляются как расстояние в строках до положения курсора.",
"linkedEditing": "Определяет, включена ли поддержка связанного редактирования в редакторе. В зависимости от языка, связанные символы, например, теги HTML, обновляются при редактировании.",
"linkedEditing": "Определяет, включена ли поддержка связанного редактирования в редакторе. В зависимости от языка, связанные символы, например теги HTML, обновляются при редактировании.",
"links": "Определяет, должен ли редактор определять ссылки и делать их доступными для щелчка.",
"matchBrackets": "Выделять соответствующие скобки.",
"minimap.autohide": "Определяет, скрыта ли мини-карта автоматически.",
"minimap.enabled": "Определяет, отображается ли мини-карта.",
"minimap.maxColumn": "Ограничивает ширину мини-карты, чтобы количество отображаемых столбцов не превышало определенное количество.",
"minimap.renderCharacters": "Отображает фактические символы в строке вместо цветных блоков.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "Мини-карта имеет такой же размер, что и содержимое редактора (возможна прокрутка).",
"mouseWheelScrollSensitivity": "Множитель, используемый для параметров deltaX и deltaY событий прокрутки колесика мыши.",
"mouseWheelZoom": "Изменение размера шрифта в редакторе при нажатой клавише CTRL и движении колесика мыши.",
"multiCursorLimit": "Управляет максимальным числом курсоров, которые могут одновременно отображаться в активном редакторе.",
"multiCursorMergeOverlapping": "Объединить несколько курсоров, когда они перекрываются.",
"multiCursorModifier": "Модификатор, который будет использоваться для добавления нескольких курсоров с помощью мыши. Жесты мыши \"Перейти к определению\" и \"Открыть ссылку\" будут изменены так, чтобы они не конфликтовали модификатором нескольких курсоров. [Подробнее](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "Модификатор, который будет использоваться для добавления нескольких курсоров с помощью мыши. Жесты мыши \"Перейти к определению\" и \"Открыть ссылку\" будут изменены так, чтобы они не конфликтовали c [multicursor modifier](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier.alt": "Соответствует клавише ALT в Windows и Linux и клавише OPTION в macOS.",
"multiCursorModifier.ctrlCmd": "Соответствует клавише CTRL в Windows и Linux и клавише COMMAND в macOS.",
"multiCursorPaste": "Управляет вставкой, когда число вставляемых строк соответствует числу курсоров.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Определяет, следует ли переключить фокус на встроенный редактор или дерево в виджете обзора.",
"peekWidgetDefaultFocus.editor": "Фокусировка на редакторе при открытии обзора",
"peekWidgetDefaultFocus.tree": "Фокусировка на дереве при открытии обзора",
"quickSuggestions": "Определяет, должны ли при вводе текста автоматически отображаться предложения.",
"quickSuggestions": "Определяет, должны ли предложения автоматически отображаться при вводе. Этот параметр можно выбрать при вводе примечаний, строк и другого кода. Быстрые предложения можно настроить для отображения в виде фантомного текста или в мини-приложении предложений. Необходимо также помнить о параметре {0}, который управляет активированием предложений специальными символами.",
"quickSuggestions.comments": "Разрешение кратких предложений в комментариях.",
"quickSuggestions.other": "Разрешение кратких предложений вне строк и комментариев.",
"quickSuggestions.strings": "Разрешение кратких предложений в строках.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Определяет, когда элементы управления свертывания отображаются на переплете.",
"showFoldingControls.always": "Всегда показывать свертываемые элементы управления.",
"showFoldingControls.mouseover": "Показывать только элементы управления свертывания, когда указатель мыши находится над переплетом.",
"showFoldingControls.never": "Никогда не показывать элементы управления свертыванием и уменьшать размер переплета.",
"showUnused": "Управляет скрытием неиспользуемого кода.",
"smoothScrolling": "Определяет, будет ли использоваться анимация при прокрутке содержимого редактора",
"snippetSuggestions": "Управляет отображением фрагментов вместе с другими предложениями и их сортировкой.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Эмулировать поведение выделения для символов табуляции при использовании пробелов для отступа. Выделение будет применено к позициям табуляции.",
"suggest.filterGraceful": "Управляет тем, допускаются ли небольшие опечатки в предложениях фильтрации и сортировки.",
"suggest.insertMode": "Определяет, будут ли перезаписываться слова при принятии вариантов завершения. Обратите внимание, что это зависит от расширений, использующих эту функцию.",
"suggest.insertMode.always": "Всегда выбирать предложение при автоматической активации IntelliSense.",
"suggest.insertMode.insert": "Вставить предложение без перезаписи текста справа от курсора.",
"suggest.insertMode.never": "Никогда не выбирать предложение при автоматической активации IntelliSense.",
"suggest.insertMode.replace": "Вставить предложение и перезаписать текст справа от курсора.",
"suggest.insertMode.whenQuickSuggestion": "Выбирать предложение только при активации IntelliSense по мере ввода.",
"suggest.insertMode.whenTriggerCharacter": "Выбирать предложение только при активации IntelliSense с помощью триггерного символа.",
"suggest.localityBonus": "Определяет, следует ли учитывать при сортировке слова, расположенные рядом с курсором.",
"suggest.maxVisibleSuggestions.dep": "Этот параметр является нерекомендуемым. Теперь размер мини-приложения предложений можно изменить.",
"suggest.preview": "Определяет, следует ли просматривать результат предложения в редакторе.",
"suggest.selectionMode": "Определяет, выбирается ли предложение при отображении мини-приложения. Обратите внимание, что этот параметр применяется только к автоматически активированным предложениям (\"#editor.quickSuggestions#\" и \"#editor.suggestOnTriggerCharacters#\"), и что предложение всегда выбирается при явном вызове, например с помощью сочетания клавиш \"CTRL+ПРОБЕЛ\".",
"suggest.shareSuggestSelections": "Определяет, используются ли сохраненные варианты выбора предложений совместно несколькими рабочими областями и окнами (требуется \"#editor.suggestSelection#\").",
"suggest.showIcons": "Указывает, нужно ли отображать значки в предложениях.",
"suggest.showInlineDetails": "Определяет, отображаются ли сведения о предложении встроенным образом вместе с меткой или только в мини-приложении сведений.",
"suggest.showInlineDetails": "Определяет, отображаются ли сведения о предложении в строке вместе с меткой или только в мини-приложении сведений.",
"suggest.showStatusBar": "Определяет видимость строки состояния в нижней части виджета предложений.",
"suggest.snippetsPreventQuickSuggestions": "Определяет, запрещает ли активный фрагмент кода экспресс-предложения.",
"suggestFontSize": "Размер шрифта мини-приложения с предложениями. Если установить значение \"0\", будет использовано значение \"#editor.fontSize#\".",
"suggestLineHeight": "Высота строки мини-приложения с предложениями. Если установить значение \"0\", будет использовано значение \"#editor.lineHeight#\". Минимальное значение — 8.",
"suggestFontSize": "Размер шрифта для мини-приложения предложений. Если установлено {0}, используется значение {1}.",
"suggestLineHeight": "Высота строки для мини-приложения предложений. Если установлено {0}, используется значение {1}. Минимальное значение — 8.",
"suggestOnTriggerCharacters": "Определяет, должны ли при вводе триггерных символов автоматически отображаться предложения.",
"suggestSelection": "Управляет предварительным выбором предложений при отображении списка предложений.",
"suggestSelection.first": "Всегда выбирать первое предложение.",
@ -410,6 +465,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Отключить дополнение по TAB.",
"tabCompletion.on": "При использовании дополнения по TAB будет добавляться наилучшее предложение при нажатии клавиши TAB.",
"tabCompletion.onlySnippets": "Вставка дополнений по TAB при совпадении их префиксов. Функция работает оптимально, если параметр \"quickSuggestions\" отключен.",
"tabFocusMode": "Определяет, получает ли редактор вкладки или откладывает ли их в рабочую среду для навигации.",
"unfoldOnClickAfterEndOfLine": "Определяет, будет ли щелчок пустого содержимого после свернутой строки развертывать ее.",
"unicodeHighlight.allowedCharacters": "Определяет разрешенные символы, которые не выделяются.",
"unicodeHighlight.allowedLocales": "Символы Юникода, распространенные в разрешенных языках, не выделяются.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Необычные символы завершения строки игнорируются.",
"unusualLineTerminators.prompt": "Для необычных символов завершения строки запрашивается удаление.",
"useTabStops": "Вставка и удаление пробелов после позиции табуляции",
"wordBreak": "Управляет правилами разбиения по словам, используемыми для текста на китайском,японском и корейском языке (CJK).",
"wordBreak.keepAll": "Не следует использовать разрывы слов для текста на китайском, японском или корейском языке (CJK). Для других текстов используется обычное поведение.",
"wordBreak.normal": "Использовать правило разрыва строк по умолчанию.",
"wordSeparators": "Символы, которые будут использоваться как разделители слов при выполнении навигации или других операций, связанных со словами.",
"wordWrap": "Управляет тем, как следует переносить строки.",
"wordWrap.bounded": "Строки будут перенесены по минимальному значению из двух: ширина окна просмотра и \"#editor.wordWrapColumn#\".",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "Перенесенные строки получат отступ, увеличенный на единицу по сравнению с родительской строкой. ",
"wrappingIndent.none": "Без отступа. Перенос строк начинается со столбца 1.",
"wrappingIndent.same": "Перенесенные строки получат тот же отступ, что и родительская строка.",
"wrappingStrategy": "Управляет алгоритмом, вычисляющим точки переноса.",
"wrappingStrategy": "Управляет алгоритмом, который вычисляет точки переноса. Обратите внимание, что в режиме специальных возможностей будет использован расширенный алгоритм, чтобы обеспечить наибольшее удобство работы.",
"wrappingStrategy.advanced": "Делегирует вычисление точек переноса браузеру. Это медленный алгоритм, который может привести к зависаниям при обработке больших файлов, но работает правильно во всех случаях.",
"wrappingStrategy.simple": "Предполагает, что все символы имеют одинаковую ширину. Это быстрый алгоритм, который работает правильно для моноширинных шрифтов и некоторых скриптов (например, латинских символов), где глифы имеют одинаковую ширину."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Цвет фона неактивных направляющих пар скобок (6). Требуется включить направляющие пар скобок.",
"editorCodeLensForeground": "Цвет переднего плана элемента CodeLens в редакторе",
"editorCursorBackground": "Цвет фона курсора редактора. Позволяет настраивать цвет символа, перекрываемого прямоугольным курсором.",
"editorDimmedLineNumber": "Цвет последней строки редактора, когда editor.renderFinalNewline имеет значение dimmed.",
"editorGhostTextBackground": "Цвет фона для едва различимого текста в редакторе.",
"editorGhostTextBorder": "Цвет границы для едва различимого текста в редакторе.",
"editorGhostTextForeground": "Цвет переднего плана для едва различимого текста в редакторе.",
"editorGutter": "Цвет фона поля в редакторе. В поле размещаются отступы глифов и номера строк.",
"editorIndentGuides": "Цвет направляющих для отступов редактора.",
"editorLineNumbers": "Цвет номеров строк редактора.",
"editorOverviewRulerBackground": "Цвет фона обзорной линейки редактора. Используется, только если мини-карта включена и размещена в правой части редактора.",
"editorOverviewRulerBackground": "Цвет фона обзорной линейки редактора.",
"editorOverviewRulerBorder": "Цвет границы для линейки в окне просмотра.",
"editorRuler": "Цвет линейки редактора.",
"editorUnicodeHighlight.background": "Цвет фона, используемый для выделения символов Юникода.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "При нажатии клавиши TAB в текущем редакторе фокус ввода переместится на следующий элемент, способный его принять. Команду {0} сейчас невозможно выполнить с помощью настраиваемого сочетания клавиш.",
"toggleHighContrast": "Переключить высококонтрастную тему"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "Символы: {0}",
"showMore": "Показать больше ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Начальная точка установлена в {0}:{1}",
"cancelSelectionAnchor": "Отменить начальную точку выделения",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Копировать как",
"miCopy": "&&Копировать",
"miCut": "&&Вырезать",
"miPaste": "&&Вставить"
"miPaste": "&&Вставить",
"share": "Поделиться"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "При применении действия кода произошла неизвестная ошибка"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "При применении действия кода произошла неизвестная ошибка",
"args.schema.apply": "Определяет, когда применяются возвращенные действия.",
"args.schema.apply.first": "Всегда применять первое возвращенное действие кода.",
"args.schema.apply.ifSingle": "Применить первое действие возвращенного кода, если оно является единственным.",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "Организация импортов",
"quickfix.trigger.label": "Быстрое исправление...",
"refactor.label": "Рефакторинг...",
"refactor.preview.label": "Рефакторинг с предварительной версией...",
"source.label": "Действие с исходным кодом..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Включить или отключить отображение заголовков групп в меню действий кода."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Повторно создать...",
"codeAction.widget.id.extract": "Извлечь...",
"codeAction.widget.id.inline": "Встроенная...",
"codeAction.widget.id.more": "Дополнительные действия...",
"codeAction.widget.id.move": "Переместить…",
"codeAction.widget.id.quickfix": "Быстрое исправление...",
"codeAction.widget.id.source": "Действие с исходным кодом...",
"codeAction.widget.id.surround": "Разместить во фрагменте..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Скрыть отключенные",
"showMoreActions": "Показать отключенные"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Показать действия кода",
"codeActionWithKb": "Показать действия кода ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "Переключить комментарий &&строки"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Показать контекстное меню редактора"
"action.showContextMenu.label": "Показать контекстное меню редактора",
"context.minimap.minimap": "Мини-карта",
"context.minimap.renderCharacters": "Отрисовка символов",
"context.minimap.size": "Размер по вертикали",
"context.minimap.size.fill": "Заполнить",
"context.minimap.size.fit": "Подогнать",
"context.minimap.size.proportional": "Пропорционально",
"context.minimap.slider": "Ползунок",
"context.minimap.slider.always": "Всегда",
"context.minimap.slider.mouseover": "Наведение указателя мыши"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Включить или отключить текущие изменения из расширений при вставке."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Запуск обработчиков вставки..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "Повтор действия курсора",
"cursor.undo": "Отмена действия курсора"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Запуск обработчиков передачи..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Выполняются ли в редакторе операции, допускающие отмену, например, \"Показать ссылки\""
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "Переопределяет флаг \"Учитывать регистр\".\r\nЭтот флаг не будет сохранен на будущее.\r\n0: бездействие\r\n1: true\r\n2: false",
"actions.find.preserveCaseOverride": "Переопределяет флаг \"Сохранить регистр\".\r\nЭтот флаг не будет сохранен на будущее.\r\n0: бездействие\r\n1: true\r\n2: false",
"actions.find.wholeWordOverride": "Переопределяет флаг \"Слово целиком\".\r\nЭтот флаг не будет сохранен на будущее.\r\n0: бездействие\r\n1: true\r\n2: false",
"findMatchAction.goToMatch": "Перейти к совпадению...",
"findMatchAction.inputPlaceHolder": "Введите число, чтобы перейти к определенному совпадению (от 1 до {0})",
"findMatchAction.inputValidationMessage": "Введите число от 1 до {0}",
"findNextMatchAction": "Найти далее",
"findPreviousMatchAction": "Найти ранее",
"miFind": "&&Найти",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Отображаются только первые {0} результатов, но все операции поиска выполняются со всем текстом."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Цвет элемента управления свертыванием во внутреннем поле редактора.",
"createManualFoldRange.label": "Создать диапазон свертывания из выделенного фрагмента",
"foldAction.label": "Свернуть",
"foldAllAction.label": "Свернуть все",
"foldAllBlockComments.label": "Свернуть все блоки комментариев",
"foldAllExcept.label": "Свернуть все регионы, кроме выбранных",
"foldAllMarkerRegions.label": "Свернуть все регионы",
"foldBackgroundBackground": "Цвет фона за свернутыми диапазонами. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже декоративные элементы.",
"foldLevelAction.label": "Уровень папки {0}",
"foldRecursivelyAction.label": "Свернуть рекурсивно",
"gotoNextFold.label": "Перейти к следующему диапазону сложенных данных",
"gotoParentFold.label": "Перейти к родительскому свертыванию",
"gotoPreviousFold.label": "Перейти к предыдущему диапазону сложенных данных",
"maximum fold ranges": "Количество свертываемых регионов ограничено максимальным значением {0}. Увеличьте параметр конфигурации [\"Свертывание максимального количества регионов\"](command:workbench.action.openSettings?[\" editor.foldingMaximumRegions\"]), чтобы разрешить больше.",
"removeManualFoldingRanges.label": "Удалить диапазоны свертывания вручную",
"toggleFoldAction.label": "Переключить свертывание",
"unFoldRecursivelyAction.label": "Развернуть рекурсивно",
"unfoldAction.label": "Развернуть",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Развернуть все регионы"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Цвет элемента управления свертыванием во внутреннем поле редактора.",
"foldBackgroundBackground": "Цвет фона за свернутыми диапазонами. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже декоративные элементы.",
"foldingCollapsedIcon": "Значок для свернутых диапазонов на поле глифов редактора.",
"foldingExpandedIcon": "Значок для развернутых диапазонов на поле глифов редактора."
"foldingExpandedIcon": "Значок для развернутых диапазонов на поле глифов редактора.",
"foldingManualCollapedIcon": "Значок для свернутых вручную диапазонов на полях глифа редактора.",
"foldingManualExpandedIcon": "Значок для развернутых вручную диапазонов на полях глифа редактора."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Увеличить шрифт редактора",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Загрузка...",
"stopped rendering": "Отрисовка приостановлена для длинной строки из соображений производительности. Это можно настроить с помощью параметра editor.stopRenderingLineAfter.",
"too many characters": "Разметка пропускается для длинных строк из соображений производительности. Это можно настроить с помощью \"editor.maxTokenizationLineLength\"."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Просмотреть проблему"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Изменить отображаемый размер табуляции",
"configuredTabSize": "Настроенный размер шага табуляции",
"currentTabSize": "Текущий размер табуляции",
"defaultTabSize": "Размер табуляции по умолчанию",
"detectIndentation": "Определение отступа от содержимого",
"editor.reindentlines": "Повторно расставить отступы строк",
"editor.reindentselectedlines": "Повторно расставить отступы для выбранных строк",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "CMD + щелчок"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Принять",
"acceptWord": "Принять Word",
"action.inlineSuggest.accept": "Принять встроенное предложение",
"action.inlineSuggest.acceptNextWord": "Принять следующее слово встроенного предложения",
"action.inlineSuggest.alwaysShowToolbar": "Всегда отображать панель инструментов",
"action.inlineSuggest.hide": "Скрыть встроенное предложение",
"action.inlineSuggest.showNext": "Показывать следующее встроенное предложение",
"action.inlineSuggest.showPrevious": "Показать предыдущее встроенное предложение",
"action.inlineSuggest.trigger": "Активировать встроенное предложение",
"action.inlineSuggest.undo": "Отменить принятие слова",
"alwaysShowInlineSuggestionToolbar": "Должна ли всегда отображаться встроенная панель инструментов предложений",
"canUndoInlineSuggestion": "Выполняет ли команда \"Отменить\" отмену встроенного предложения",
"inlineSuggestionHasIndentation": "Начинается ли встроенное предложение с пробела",
"inlineSuggestionHasIndentationLessThanTabSize": "Проверяет, не является ли пробел перед встроенной рекомендацией короче, чем текст, вставляемый клавишей TAB",
"inlineSuggestionVisible": "Отображается ли встроенное предложение"
"inlineSuggestionVisible": "Отображается ли встроенное предложение",
"undoAcceptWord": "Отменить принятие Word"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Предложение:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Далее",
"parameterHintsNextIcon": "Значок для отображения подсказки следующего параметра.",
"parameterHintsPreviousIcon": "Значок для отображения подсказки предыдущего параметра.",
"previous": "Назад"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Заменить следующим значением",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Дублировать выбранное",
"editor.transformToCamelcase": "Преобразовать в \"верблюжий\" стиль",
"editor.transformToKebabcase": "Преобразовать в кебаб-кейс",
"editor.transformToLowercase": "Преобразовать в нижний регистр",
"editor.transformToSnakecase": "Преобразовать в написание с подчеркиваниями",
"editor.transformToTitlecase": "Преобразовать в заглавные буквы",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "Выполнение команды {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Не удается выполнить изменение в редакторе только для чтения",
"messageVisible": "Отображается ли сейчас в редакторе внутреннее сообщение"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Переместить последний выделенный фрагмент в предыдущее найденное совпадение",
"mutlicursor.addCursorsToBottom": "Добавить курсоры ниже",
"mutlicursor.addCursorsToTop": "Добавить курсоры выше",
"mutlicursor.focusNextCursor": "Фокусировка на следующем курсоре",
"mutlicursor.focusNextCursor.description": "Фокусируется на следующем курсоре",
"mutlicursor.focusPreviousCursor": "Фокусировка на предыдущем курсоре",
"mutlicursor.focusPreviousCursor.description": "Фокусируется на предыдущем курсоре",
"mutlicursor.insertAbove": "Добавить курсор выше",
"mutlicursor.insertAtEndOfEachLineSelected": "Добавить курсоры к окончаниям строк",
"mutlicursor.insertBelow": "Добавить курсор ниже",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Цвет фона поля в окне быстрого редактора.",
"peekViewEditorMatchHighlight": "Цвет выделения совпадений в быстром редакторе.",
"peekViewEditorMatchHighlightBorder": "Граница выделения совпадений в быстром редакторе.",
"peekViewEditorStickScrollBackground": "Цвет фона залипания прокрутки в окне быстрого редактора.",
"peekViewResultsBackground": "Цвет фона в списке результатов представления быстрого редактора.",
"peekViewResultsFileForeground": "Цвет переднего плана узлов файла в списке результатов быстрого редактора.",
"peekViewResultsMatchForeground": "Цвет переднего плана узлов строки в списке результатов быстрого редактора.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "параметры типа ({0})",
"variable": "переменные ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Не удается выполнить изменение в редакторе только для чтения",
"editor.simple.readonly": "Не удается внести изменения во входные данные только для чтения"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "«{0}» успешно переименован в «{1}». Сводка: {2}",
"enablePreview": "Включить/отключить возможность предварительного просмотра изменений перед переименованием",
"label": "Переименование \"{0}\"",
"label": "Переименование \"{0}\" в \"{1}\"",
"no result": "Результаты отсутствуют.",
"quotableLabel": "Переименование {0}",
"quotableLabel": "Переименование {0} в {1}",
"rename.failed": "Операции переименования не удалось вычислить правки",
"rename.failedApply": "Операции переименования не удалось применить правки",
"rename.label": "Переименовать символ",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Указывает, существует ли следующая позиция табуляции в режиме фрагментов",
"hasPrevTabstop": "Указывает, существует ли предыдущая позиция табуляции в режиме фрагментов",
"inSnippetMode": "Находится ли текущий редактор в режиме фрагментов"
"inSnippetMode": "Находится ли текущий редактор в режиме фрагментов",
"next": "Перейти к следующему заполнителю..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Апрель",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "среда",
"WednesdayShort": "Ср"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&&Залипание прокрутки",
"mitoggleStickyScroll": "&&Переключить залипание прокрутки",
"stickyScroll": "Залипание прокрутки",
"toggleStickyScroll": "Переключить залипание прокрутки"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Вставляются ли предложения при нажатии клавиши ВВОД",
"suggestWidgetDetailsVisible": "Отображаются ли сведения о предложениях",
"suggestWidgetHasSelection": "Находится ли какое-либо предложение в фокусе",
"suggestWidgetMultipleSuggestions": "Существует ли несколько предложений для выбора",
"suggestionCanResolve": "Поддерживает ли текущее предложение разрешение дополнительных сведений",
"suggestionHasInsertAndReplaceRange": "Есть ли у текущего предложения варианты поведения \"вставка\" и \"замена\"",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Значок для получения дополнительных сведений в мини-приложении предложений."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Цвет переднего плана для символов массива. Эти символы отображаются в структуре, элементе навигации и мини-приложении предложений.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "Файл \"{0}\" содержит один или несколько необычных символов завершения строки, таких как разделитель строк (LS) или разделитель абзацев (PS).\r\n\r\nРекомендуется удалить их из файла. Удаление этих символов можно настроить с помощью параметра \"editor.unusualLineTerminators\".",
"unusualLineTerminators.fix": "Удалить необычные символы завершения строки",
"unusualLineTerminators.fix": "&&Удалить необычные символы завершения строки",
"unusualLineTerminators.ignore": "Пропустить",
"unusualLineTerminators.message": "Обнаружены необычные символы завершения строки",
"unusualLineTerminators.title": "Необычные символы завершения строки"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Цвет маркера обзорной линейки для выделения символов. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже элементы оформления.",
"overviewRulerWordHighlightStrongForeground": "Цвет маркера обзорной линейки для выделения символов доступа на запись. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.",
"overviewRulerWordHighlightTextForeground": "Цвет маркера обзорной линейки текстового вхождения символа. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже элементы оформления.",
"wordHighlight": "Цвет фона символа при доступе на чтение, например, при чтении переменной. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.",
"wordHighlight.next.label": "Перейти к следующему выделению символов",
"wordHighlight.previous.label": "Перейти к предыдущему выделению символов",
"wordHighlight.trigger.label": "Включить или отключить выделение символов",
"wordHighlightBorder": "Цвет границы символа при доступе на чтение, например, при считывании переменной.",
"wordHighlightStrong": "Цвет фона для символа во время доступа на запись, например при записи в переменную. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.",
"wordHighlightStrongBorder": "Цвет границы символа при доступе на запись, например, при записи переменной. "
"wordHighlightStrongBorder": "Цвет границы символа при доступе на запись, например, при записи переменной. ",
"wordHighlightText": "Цвет фона текстового вхождения символа. Этот цвет не должен быть непрозрачным, чтобы не скрывать расположенные ниже элементы оформления.",
"wordHighlightTextBorder": "Цвет границы текстового вхождения символа."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Перейти к следующему выделению символов",
"wordHighlight.previous.label": "Перейти к предыдущему выделению символов",
"wordHighlight.trigger.label": "Включить или отключить выделение символов"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Удалить слово"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Разработчик",
"help": "Справка",
"preferences": "Параметры",
"test": "Тест",
"view": "Представление"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Скрыть",
"resetThisMenu": "Сбросить меню"
},
"vs/platform/actions/common/menuService": {
"hide.label": "Скрыть \"{0}\""
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Мини-приложения действий",
"customQuickFixWidget.labels": "{0}, причина отключения: {1}",
"label": "{0}, чтобы применить",
"label-preview": "{0}, чтобы применить, {1} для предварительного просмотра"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Принять выбранное действие",
"codeActionMenuVisible": "Отображается ли список мини-приложений действий",
"hideCodeActionWidget.title": "Скрыть мини-приложение действия",
"previewSelected.title": "Предварительный просмотр выбранного действия",
"selectNextCodeAction.title": "Выбрать следующее действие",
"selectPrevCodeAction.title": "Выбрать предыдущее действие"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Удалена разностная строка",
"audioCues.diffLineInserted": "Вставлена разностная строка",
"audioCues.diffLineModified": "Изменена строка различий",
"audioCues.lineHasBreakpoint.name": "Точка останова в строке",
"audioCues.lineHasError.name": "Ошибка в строке",
"audioCues.lineHasFoldedArea.name": "Сложенная область в строке",
"audioCues.lineHasInlineSuggestion.name": "Встроенная рекомендация в строке",
"audioCues.lineHasWarning.name": "Предупреждение в строке",
"audioCues.noInlayHints": "Отсутствие встроенных подсказок в строке",
"audioCues.notebookCellCompleted": "Ячейка записной книжки выполнена",
"audioCues.notebookCellFailed": "Сбой ячейки записной книжки",
"audioCues.onDebugBreak.name": "Отладчик остановлен в точке останова",
"audioCues.taskCompleted": "Задача завершена",
"audioCues.taskFailed": "Сбой задачи",
"audioCues.terminalBell": "Звонок терминала",
"audioCues.terminalCommandFailed": "Сбой команды терминала",
"audioCues.terminalQuickFix.name": "Быстрое исправление терминала"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "Невозможно зарегистрировать \"{0}\". Уже имеется регистрация {2} для связанной политики {1}.",
"config.property.duplicate": "Невозможно зарегистрировать \"{0}\". Это свойство уже зарегистрировано.",
"config.property.empty": "Не удается зарегистрировать пустое свойство",
"config.property.languageDefault": "Невозможно зарегистрировать \"{0}\". Оно соответствует шаблону свойства '\\\\[.*\\\\]$' для описания параметров редактора, определяемых языком. Используйте участие configurationDefaults.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "Используется ли операционная система Linux",
"isMac": "Используется ли операционная система macOS",
"isMacNative": "Используется ли операционная система macOS на платформе, отличной от браузерной",
"isMobile": "Является ли платформа мобильным браузером",
"isWeb": "Является ли платформа браузерной",
"isWindows": "Используется ли операционная система Windows"
"isWindows": "Используется ли операционная система Windows",
"productQualityType": "Тип качества VS Code"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "Отмена",
"moreFile": "...1 дополнительный файл не показан",
"moreFiles": "...не показано дополнительных файлов: {0}"
"moreFiles": "...не показано дополнительных файлов: {0}",
"okButton": "&&ОК",
"yesButton": "&&Да"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "Файл имеет слишком большой размер для открытия в редакторе без имени. Отправьте этот файл в обозреватель файлов, а затем повторите попытку."
},
"vs/platform/files/common/files": {
"sizeB": "{0} Б",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "Коэффициент увеличения скорости прокрутки при нажатии клавиши ALT.",
"Mouse Wheel Scroll Sensitivity": "Множитель, используемый для параметров deltaX и deltaY событий прокрутки колесика мыши.",
"automatic keyboard navigation setting": "Указывает, активируется ли навигация с помощью клавиатуры в списках и деревьях автоматически простым вводом. Если задано значение \"false\", навигация с клавиатуры активируется только при выполнении команды \"list.toggleKeyboardNavigation\", для которой можно назначить сочетание клавиш.",
"defaultFindMatchTypeSettingKey": "Управляет типом сопоставления, используемым при поиске списков и деревьев в Workbench.",
"defaultFindMatchTypeSettingKey.contiguous": "Использовать непрерывное сопоставление при поиске.",
"defaultFindMatchTypeSettingKey.fuzzy": "Использовать нечеткое соответствие при поиске.",
"defaultFindModeSettingKey": "Управляет режимом поиска по умолчанию для списков и деревьев в Workbench.",
"defaultFindModeSettingKey.filter": "Фильтруйте элементы при поиске.",
"defaultFindModeSettingKey.highlight": "При поиске необходимо выделять элементы. При дальнейшей навигации вверх и вниз выполняется обход только выделенных элементов.",
"expand mode": "Управляет тем, как папки дерева разворачиваются при нажатии на имена папок. Обратите внимание, что этот параметр может игнорироваться в некоторых деревьях и списках, если он не применяется к ним.",
"horizontalScrolling setting": "Определяет, поддерживают ли горизонтальную прокрутку списки и деревья на рабочем месте. Предупреждение! Включение этого параметра может повлиять на производительность.",
"keyboardNavigationSettingKey": "Управляет стилем навигации с клавиатуры для списков и деревьев в Workbench. Доступен простой режим, режим выделения и режим фильтрации.",
"keyboardNavigationSettingKey.filter": "Фильтр навигации с клавиатуры позволяет отфильтровать и скрыть все элементы, не соответствующие вводимым с клавиатуры данным.",
"keyboardNavigationSettingKey.highlight": "Функция подсветки навигации с клавиатуры выделяет элементы, соответствующие вводимым с клавиатуры данным. При дальнейшей навигации вверх и вниз выполняется обход только выделенных элементов.",
"keyboardNavigationSettingKey.simple": "Про простой навигации с клавиатуры выбираются элементы, соответствующие вводимым с клавиатуры данным. Сопоставление осуществляется только по префиксам.",
"keyboardNavigationSettingKeyDeprecated": "Вместо этого используйте \"workbench.list.defaultFindMode\" и \"workbench.list.typeNavigationMode\".",
"list smoothScrolling setting": "Управляет тем, используется ли плавная прокрутка для списков и деревьев.",
"list.scrollByPage": "Определяет, следует ли щелкать полосу прокрутки постранично.",
"multiSelectModifier": "Модификатор, который будет использоваться для добавления элементов в деревьях и списках в элемент множественного выбора с помощью мыши (например, в проводнике, в открытых редакторах и в представлении scm). Жесты мыши \"Открыть сбоку\" (если они поддерживаются) будут изменены таким образом, чтобы они не конфликтовали с модификатором элемента множественного выбора.",
"multiSelectModifier.alt": "Соответствует клавише ALT в Windows и Linux и клавише OPTION в macOS.",
"multiSelectModifier.ctrlCmd": "Соответствует клавише CTRL в Windows и Linux и клавише COMMAND в macOS.",
"openModeModifier": "Управляет тем, как открывать элементы в деревьях и списках с помощью мыши (если поддерживается). Обратите внимание, что этот параметр может игнорироваться в некоторых деревьях и списках, если он не применяется к ним.",
"render tree indent guides": "Определяет, нужно ли в дереве отображать направляющие отступа.",
"tree indent setting": "Определяет отступ для дерева в пикселях.",
"typeNavigationMode": "Управляет навигацией по типам в списках и деревьях в рабочей среде. Если установлено значение \"триггер\", навигация по типу начинается после запуска команды \"list.triggerTypeNavigation\".",
"workbenchConfigurationTitle": "Рабочее место"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Предупреждение"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "Команда \"{0}\" привела к ошибке ({1})",
"canNotRun": "Команда \"{0}\" привела к ошибке",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "часто используемые",
"morecCommands": "другие команды",
"recentlyUsed": "недавно использованные"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "команды редактора",
"globalCommands": "глобальные команды",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Другой",
"inputModeEntry": "Нажмите клавишу ВВОД, чтобы подтвердить введенные данные, или ESCAPE для отмены",
"inputModeEntryDescription": "{0} (нажмите клавишу ВВОД, чтобы подтвердить введенные данные, или ESCAPE для отмены)",
"ok": "ОК",
"quickInput.back": "Назад",
"quickInput.backWithKeybinding": "Назад ({0})",
"quickInput.checkAll": "Переключить все флажки",
"quickInput.countSelected": "{0} выбрано",
"quickInput.steps": "{0} / {1}",
"quickInput.visibleCount": "Результаты: {0}",
"quickInputBox.ariaLabel": "Введите текст, чтобы уменьшить число результатов."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Быстрый ввод"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "Щелкните, чтобы выполнить команду \"{0}\""
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Дополнительная граница вокруг активных элементов, которая отделяет их от других элементов для улучшения контраста.",
"activeLinkForeground": "Цвет активных ссылок.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "Фоновый цвет элементов навигации.",
"breadcrumbsFocusForeground": "Цвет элементов навигации, находящихся в фокусе.",
"breadcrumbsSelectedBackground": "Фоновый цвет средства выбора элементов навигации.",
"breadcrumbsSelectedForegound": "Цвет выделенных элементов навигации.",
"breadcrumbsSelectedForeground": "Цвет выделенных элементов навигации.",
"buttonBackground": "Цвет фона кнопки.",
"buttonBorder": "Цвет границы кнопки.",
"buttonForeground": "Цвет переднего плана кнопки.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "Цвет фона вторичной кнопки.",
"buttonSecondaryForeground": "Цвет переднего плана вторичной кнопки.",
"buttonSecondaryHoverBackground": "Цвет фона вторичной кнопки при наведении курсора мыши.",
"buttonSeparator": "Цвет разделителя кнопок.",
"chartsBlue": "Синий цвет, используемый в визуализациях диаграмм.",
"chartsForeground": "Цвет переднего плана на диаграммах.",
"chartsGreen": "Зеленый цвет, используемый в визуализациях диаграмм.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Цвет фона мини-приложения флажка.",
"checkbox.border": "Цвет границы мини-приложения флажка.",
"checkbox.foreground": "Цвет переднего плана мини-приложения флажка.",
"checkbox.select.background": "Цвет фона виджета флажка при выборе элемента, в котором он находится.",
"checkbox.select.border": "Цвет границы виджета флажка, когда выбран элемент, в котором он находится.",
"contrastBorder": "Дополнительная граница вокруг элементов, которая отделяет их от других элементов для улучшения контраста.",
"descriptionForeground": "Цвет текста элемента, содержащего пояснения, например, для метки.",
"diffDiagonalFill": "Цвет диагональной заливки для редактора несовпадений. Диагональная заливка используется в размещаемых рядом представлениях несовпадений.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Цвет фона для поля, где удалены строки.",
"diffEditorRemovedLines": "Цвет фона для удаленных строк. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.",
"diffEditorRemovedOutline": "Цвет контура для удаленных строк.",
"disabledForeground": "Общий цвет переднего плана для отключенных элементов. Этот цвет используется только в том случае, если он не переопределен компонентом.",
"dropdownBackground": "Фон раскрывающегося списка.",
"dropdownBorder": "Граница раскрывающегося списка.",
"dropdownForeground": "Передний план раскрывающегося списка.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Цвет выделенного текста в режиме высокого контраста.",
"editorSelectionHighlight": "Цвет для областей, содержимое которых совпадает с выбранным фрагментом. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.",
"editorSelectionHighlightBorder": "Цвет границы регионов с тем же содержимым, что и в выделении.",
"editorStickyScrollBackground": "Цвет фона для прокрутки с залипанием в редакторе",
"editorStickyScrollHoverBackground": "Цвет фона для прокрутки с залипанием при наведении курсора в редакторе",
"editorWarning.background": "Цвет фона для текста предупреждения в редакторе. Цвет не должен быть непрозрачным, чтобы не скрыть расположенные ниже элементы оформления.",
"editorWarning.foreground": "Цвет волнистой линии для выделения предупреждений в редакторе.",
"editorWidgetBackground": "Цвет фона виджетов редактора, таких как найти/заменить.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Цвет фона для мини-приложения фильтра типов в списках и деревьях.",
"listFilterWidgetNoMatchesOutline": "Цвет контура для мини-приложения фильтра типов в списках и деревьях при отсутствии совпадений.",
"listFilterWidgetOutline": "Цвет контура для мини-приложения фильтра типов в списках и деревьях.",
"listFilterWidgetShadow": "Цвет затемнения для мини-приложения фильтра типов в списках и деревьях.",
"listFocusAndSelectionOutline": "Цвет контура находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен и выбран. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.",
"listFocusBackground": "Фоновый цвет находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.",
"listFocusForeground": "Цвет переднего плана находящегося в фокусе элемента List/Tree, когда элемент List/Tree активен. На активном элементе List/Tree есть фокус клавиатуры, на неактивном — нет.",
"listFocusHighlightForeground": "Цвет переднего плана для выделения соответствия выделенных элементов при поиске по элементу List/Tree.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Фон панели инструментов при удержании указателя мыши над действиями",
"toolbarHoverBackground": "Фон панели инструментов при наведении указателя мыши на действия",
"toolbarHoverOutline": "Контур панели инструментов при наведении указателя мыши на действия",
"treeInactiveIndentGuidesStroke": "Цвет штриха дерева для неактивных направляющих отступа.",
"treeIndentGuidesStroke": "Цвет штриха дерева для направляющих отступа.",
"warningBorder": "Цвет границы для окон предупреждений в редакторе.",
"widgetBorder": "Цвет границы мини-приложений редактора, таких как \"Найти/заменить\".",
"widgetShadow": "Цвет тени мини-приложений редактора, таких как \"Найти/заменить\"."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Значок для действия закрытия в мини-приложениях."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "Отмена",
"cannotResourceRedoDueToInProgressUndoRedo": "Не удалось повторить действие \"{0}\", так как уже выполняется операция отмены или повтора действия",
"cannotResourceUndoDueToInProgressUndoRedo": "Не удалось отменить действие \"{0}\", так как уже выполняется операция отмены или повтора действия",
"cannotWorkspaceRedo": "Не удалось повторить операцию \"{0}\" для всех файлов. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "Не удалось отменить действие \"{0}\" для всех файлов, так как в {1} уже выполняется операция отмены или повтора действия",
"confirmDifferentSource": "Вы хотите отменить \"{0}\"?",
"confirmDifferentSource.no": "Нет",
"confirmDifferentSource.yes": "Да",
"confirmDifferentSource.yes": "&&Да",
"confirmWorkspace": "Вы хотите отменить \"{0}\" для всех файлов?",
"externalRemoval": "Следующие файлы были закрыты и изменены на диске: {0}.",
"noParallelUniverses": "Следующие файлы были изменены несовместимым образом: {0}.",
"nok": "Отменить этот файл",
"ok": "Отменить действие в нескольких файлах ({0})"
"nok": "Отменить этот &&файл",
"ok": "&&Отменить действие в файлах {0}"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Рабочая область кода"

404
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/tr.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "Diğer Eylemler..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "İletişim Kutusunu Kapat",
"dialogErrorMessage": "Hata",
"dialogInfoMessage": "Bilgi",
"dialogPendingMessage": "Sürüyor",
"dialogWarningMessage": "Uyarı",
"ok": "Tamam"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "Diğer Eylemler..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "giriş"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "Büyük/Küçük Harf Eşleştir",
"regexDescription": "Normal İfade Kullan",
"wordsDescription": "Sözcüğün Tamamını Eşleştir"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "giriş",
"label.preserveCaseToggle": "Büyük/Küçük Harfi Koru"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "Sınırsız"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "Kutu Seç"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "Diğer Eylemler..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "Temizle",
"disable filter on type": "Türe Göre Filtrelemeyi Devre Dışı Bırak",
"empty": "Öğe bulunamadı",
"enable filter on type": "Türe Göre Filtrelemeyi Etkinleştir",
"found": "{1} öğeden {0} tanesi eşleşti"
"close": "Kapat",
"filter": "Filtre",
"fuzzySearch": "Benzer Öğe Eşleşmesi",
"not found": "Öğe bulunamadı.",
"type to filter": "Filtrelemek için yazın",
"type to search": "Aramak için yazın"
},
"vs/base/common/actions": {
"submenu.empty": "(boş)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "Özel",
"inputModeEntry": "Girişinizi onaylamak için 'Enter' tuşuna, iptal etmek için 'Escape' tuşuna basın",
"inputModeEntryDescription": "{0} (Onaylamak için 'Enter' tuşuna, iptal etmek için 'Escape' tuşuna basın)",
"ok": "Tamam",
"quickInput.back": "Geri",
"quickInput.backWithKeybinding": "Geri ({0})",
"quickInput.countSelected": "{0} Seçili",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} Sonuç",
"quickInputBox.ariaLabel": "Sonuçları daraltmak için yazın."
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "Hızlı Giriş"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "Düzenleyiciye şu anda erişilemiyor. Seçenekler için {0} üzerine basın.",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "Geri Al"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "İmleçlerin sayısı {0} ile sınırlandı."
"cursors.maximum": "İmleç sayısı {0} ile sınırlandırıldı. Daha büyük değişiklikler için [bul ve değiştir](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) kullanmayı veya düzenleyici çoklu imleç sınırı ayarını artırmayı düşünün.",
"goToSetting": "Çoklu İmleç Sınırını Artırma"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " değişikliklerde gezinmek için Shift + F7’yi kullanın",
"diff.tooLarge": "Bir dosya çok büyük olduğundan dosyalar karşılaştırılamıyor.",
"diffInsertIcon": "Fark düzenleyicisindeki eklemeler için satır dekorasyonu.",
"diffRemoveIcon": "Fark düzenleyicisindeki kaldırmalar için satır dekorasyonu."
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "Düzenleyicinin CodeLens'i gösterip göstermediğini denetler.",
"detectIndentation": "Dosya, içeriğine göre açıldığında `#editor.tabSize#` ve `#editor.insertSpaces#` değerlerinin otomatik algılanıp algılanmayacağını denetler.",
"detectIndentation": "Dosya, içeriğine göre açıldığında {0} ve {1} değerlerinin otomatik olarak algılanıp algılanmayacağını denetler.",
"diffAlgorithm.experimental": "Deneysel bir fark alma algoritması kullanıyor.",
"diffAlgorithm.smart": "Varsayılan fark alma algoritmasını kullanıyor.",
"editor.experimental.asyncTokenization": "Belirteçlere ayırmanın bir çalışanda asenkron olarak gerçekleşip gerçekleşmeyeceğini kontrol eder.",
"editorConfigurationTitle": "Düzenleyici",
"ignoreTrimWhitespace": "Etkinleştirildiğinde, fark düzenleyicisi baştaki veya sondaki boşluklarda yapılan değişiklikleri yoksayar.",
"insertSpaces": "`Tab` tuşuna basıldığında boşluklar ekleyin. Bu ayar, `#editor.detectIndentation#` açık olduğunda dosya içeriğine göre geçersiz kılınır.",
"indentSize": "`#editor.tabSize#` öğesindeki değeri kullanmak üzere girintileme veya `\"tabSize\"` için kullanılan boşluk sayısı. Bu ayar, `#editor.detectIndentation#` açık olduğunda dosya içeriğine göre geçersiz kılınır.",
"insertSpaces": "`Tab` tuşuna basıldığında boşluklar ekleyin. Bu ayar, {0} açık olduğunda dosya içeriğine göre geçersiz kılınır.",
"largeFileOptimizations": "Yoğun bellek kullanan belirli özellikleri devre dışı bırakmak için büyük dosyalara yönelik özel işlem.",
"maxComputationTime": "Milisaniye olarak zaman aşımı süresi. Bu süre sonrasında fark hesaplaması iptal edilir. Zaman aşımı olmaması için 0 kullanın.",
"maxFileSize": "Farkların hesaplanacağı MB cinsinden maksimum dosya boyutu. Sınırsız için 0 kullanın.",
"maxTokenizationLineLength": "Bundan daha uzun satırlar, performansla ilgili nedenlerle belirteçlere ayrılamaz",
"renderIndicators": "Fark düzenleyicisinin eklenmiş/kaldırılmış değişiklikler için +/- işaretleri gösterip göstermeyeceğini denetler.",
"renderMarginRevertIcon": "Etkinleştirildiğinde fark düzenleyicisi, değişiklikleri geri almak üzere karakter dış boşluğunda oklar gösterir.",
"schema.brackets": "Girintiyi artıran veya azaltan köşeli ayraç sembollerini tanımlar.",
"schema.closeBracket": "Kapatma ayracı karakteri veya dize dizisi.",
"schema.colorizedBracketPairs": "Köşeli ayraç çifti renklendirmesi etkinse, iç içe yerleştirme düzeyine göre renklendirilen köşeli ayraç çiftlerini tanımlar.",
@ -140,14 +161,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.true": "Tüm renk temaları için anlamsal vurgulama etkinleştirildi.",
"sideBySide": "Fark düzenleyicisinin farkı yan yana mı, yoksa satır içinde mi göstereceğini denetler.",
"stablePeek": "İçeriklerine çift tıklandığında veya `Escape` tuşuna basıldığında bile gözatma düzenleyicilerini açık tut.",
"tabSize": "Bir sekmenin eşit olduğu boşluk sayısı. Bu ayar, '#editor.detectIndentation#' açık olduğunda dosya içeriğine göre geçersiz kılınır.",
"tabSize": "Bir sekmenin eşit olduğu boşluk sayısı. Bu ayar, {0} açık olduğunda dosya içeriğine göre geçersiz kılınır.",
"trimAutoWhitespace": "Sondaki otomatik eklenmiş boşluğu kaldır.",
"wordBasedSuggestions": "Tamamlamaların belgedeki sözcüklere göre hesaplanıp hesaplanmayacağını denetler.",
"wordBasedSuggestionsMode": "Sözcük tabanlı tamamlamaların hangi belgelerden hesaplandığını denetler.",
"wordBasedSuggestionsMode.allDocuments": "Tüm açık belgelerden sözcük önerin.",
"wordBasedSuggestionsMode.currentDocument": "Yalnızca etkin belgeden sözcük önerin.",
"wordBasedSuggestionsMode.matchingDocuments": "Aynı dildeki tüm açık belgelerden sözcük önerin.",
"wordWrap.inherit": "Satırlar `#editor.wordWrap#` ayarına göre kaydırılır.",
"wordWrap.inherit": "Satırlar {0} ayarına göre kaydırılır.",
"wordWrap.off": "Satırlar hiçbir zaman kaydırılmaz.",
"wordWrap.on": "Satırlar görünüm penceresinin genişliğinde kaydırılır."
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "'Tab' tuşuna ek olarak 'Enter' tuşu girildiğinde de önerilerin kabul edilip edilmeyeceğini denetler. Yeni satırlar ekleme ile önerileri kabul etme arasındaki belirsizlikten kaçınılmasını sağlar.",
"acceptSuggestionOnEnterSmart": "Bir öneriyi yalnızca metin değişikliği yaptığında `Enter` ile kabul edin.",
"accessibilityPageSize": "Düzenleyicide bulunan ve ekran okuyucu tarafından tek seferde okunabilecek satır sayısını denetler. Ekran okuyucu algılandığında varsayılan değer otomatik olarak 500'e ayarlanır. Uyarı: Bu, varsayılandan daha büyük sayılar ayarlandığında performansı etkiler.",
"accessibilitySupport": "Düzenleyicinin ekran okuyucular için iyileştirilmiş bir modda çalışıp çalışmayacağını denetler. Açık olarak ayarlamak, sözcük kaydırmayı devre dışı bırakır.",
"accessibilitySupport.auto": "Düzenleyici, bir Ekran Okuyucunun ekli olduğunu algılamak için platform API'lerini kullanır.",
"accessibilitySupport.off": "Düzenleyici hiçbir zaman bir Ekran Okuyucu ile kullanım için iyileştirilmez.",
"accessibilitySupport.on": "Düzenleyici, Ekran Okuyucuyla kullanım için kalıcı olarak iyileştirilir. Sözcük kaydırma devre dışı bırakılacak.",
"accessibilitySupport": "UI’in ekran okuyucular için iyileştirilmiş modda çalışıp çalışmayacağını belirler.",
"accessibilitySupport.auto": "Ekran Okuyucunun ekli olduğunu algılamak için platform API'lerini kullanın.",
"accessibilitySupport.off": "Ekran okuyucunun bağlı olmadığını varsay",
"accessibilitySupport.on": "Ekran Okuyucu ile kullanım için iyileştir",
"alternativeDeclarationCommand": "'Bildirime Git' işleminin sonucu geçerli konum olduğunda yürütülmekte olan alternatif komutun kimliği.",
"alternativeDefinitionCommand": "'Tanıma Git' işleminin sonucu geçerli konum olduğunda yürütülmekte olan alternatif komutun kimliği.",
"alternativeImplementationCommand": "'Uygulamaya Git' işleminin sonucu geçerli konum olduğunda yürütülmekte olan alternatif komutun kimliği.",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "Kullanıcı bir açma tırnağı eklediğinde, düzenleyicinin tırnağı otomatik olarak kapatıp kapatmayacağını denetler.",
"autoIndent": "Kullanıcı satır yazarken, yapıştırırken, taşırken veya girintilerken düzenleyicinin girintiyi otomatik olarak ayarlayıp ayarlayamayacağını denetler.",
"autoSurround": "Düzenleyicinin, tırnak işaretleri veya parantezler yazarken seçimleri otomatik olarak çevreleyip çevrelemeyeceğini denetler.",
"bracketPairColorization.enabled": "Köşeli ayraç çifti renklendirmesinin etkinleştirilip etkinleştirilmeyeceğini denetler. Köşeli ayraç vurgu renklerini geçersiz kılmak için '#workbench.colorCustomizations#' kullanın.",
"bracketPairColorization.enabled": "Köşeli ayraç çifti renklendirmesinin etkinleştirilip etkinleştirilmeyeceğini denetler. Köşeli ayraç vurgu renklerini geçersiz kılmak için{0} kullanın.",
"bracketPairColorization.independentColorPoolPerBracketType": "Her köşeli ayraç türünün kendi bağımsız renk havuzuna sahip olup olmadığını denetler.",
"codeActions": "Düzenleyicide kod eylemi ampulünü etkinleştirir.",
"codeActions": "Düzenleyicide Code Action ampulünü etkinleştirir.",
"codeLens": "Düzenleyicinin CodeLens'i gösterip göstermediğini denetler.",
"codeLensFontFamily": "CodeLens için yazı tipi ailesini denetler.",
"codeLensFontSize": "CodeLens için piksel cinsinden yazı tipi boyutunu denetler. `0` olarak ayarlandığında, `#editor.fontSize#` değerinin %90'ı kullanılır.",
"codeLensFontSize": "CodeLens için yazı tipi boyutunu piksel cinsinden kontrol eder. 0 olarak ayarlandığında, \"#editor.fontSize#\" öğesinin %90'ı kullanılır.",
"colorDecorators": "Düzenleyicinin satır içi renk dekoratörlerini ve renk seçiciyi işleyip işlemeyeceğini denetler.",
"colorDecoratorsLimit": "Düzenleyicide aynı anda işlenebilecek en fazla renk dekoratörü sayısını belirler.",
"columnSelection": "Farenin ve tuşların seçiminin sütun seçimi yapmasını etkinleştir.",
"comments.ignoreEmptyLines": "Satır açıklamaları için açma/kapama, ekleme veya kaldırma eylemlerinde boş satırların yoksayılıp yoksayılmayacağını denetler.",
"comments.insertSpace": "Açıklama yazılırken bir boşluk karakteri eklenip eklenmeyeceğini denetler.",
"copyWithSyntaxHighlighting": "Söz dizimi vurgulamasının panoya kopyalanıp kopyalanmayacağını denetler.",
"cursorBlinking": "İmleç animasyon stilini denetler.",
"cursorSmoothCaretAnimation": "Düzgün giriş işareti animasyonunun etkinleştirilip etkinleştirilmeyeceğini denetler.",
"cursorSmoothCaretAnimation.explicit": "Düz şapka animasyonu yalnızca kullanıcı imleci belli bir hareketle hareket ettirdiğinde etkinleştirilir.",
"cursorSmoothCaretAnimation.off": "Düz şapka animasyonu devre dışı bırakıldı.",
"cursorSmoothCaretAnimation.on": "Düz şapka animasyonu her zaman etkindir.",
"cursorStyle": "İmleç stilini denetler.",
"cursorSurroundingLines": "İmlecin çevresindeki görünür önceki ve sondaki satırların minimum sayısını denetler. Diğer düzenleyicilerde 'scrollOff' veya 'scrollOffset' olarak bilinir.",
"cursorSurroundingLines": "İmlecin çevresindeki görünür önceki satırların (en az 0) ve sondaki satırların (en az 1) minimum sayısını belirler. Diğer düzenleyicilerde 'scrollOff' veya 'scrollOffset' olarak bilinir.",
"cursorSurroundingLinesStyle": "`cursorSurroundingLines` değerinin ne zaman uygulanacağını denetler.",
"cursorSurroundingLinesStyle.all": "`cursorSurroundingLines` her zaman uygulanır.",
"cursorSurroundingLinesStyle.default": "`cursorSurroundingLines` yalnızca klavye veya API aracılığıyla tetiklendiğinde uygulanır.",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "Tanıma Git fare hareketinin her zaman göz atma pencere öğesini açıp açmayacağını denetler.",
"deprecated": "Bu ayar kullanım dışı. Bunun yerine lütfen 'editor.suggest.showKeywords' veya 'editor.suggest.showSnippets' gibi ayrı ayarları kullanın.",
"dragAndDrop": "Düzenleyicinin seçimlerin sürükleme ve bırakma yoluyla taşınmasına izin verip vermeyeceğini denetler.",
"dropIntoEditor.enabled": "Bir dosyayı (düzenleyicide açmak yerine) `shift` tuşuna basılı tutarak metin düzenleyici içine sürükle ve bırak yapıp yapamayacağınızı denetler.",
"editor.autoClosingBrackets.beforeWhitespace": "Köşeli ayraçları yalnızca imleç boşluğun sol tarafında olduğunda otomatik kapat.",
"editor.autoClosingBrackets.languageDefined": "Köşeli ayraçların ne zaman otomatik kapatılacağını belirlemek için dil yapılandırmalarını kullan.",
"editor.autoClosingDelete.auto": "Bitişik kapatma tırnak işaretlerini veya köşeli ayraçlarını yalnızca bunlar otomatik olarak eklendiyse kaldırın.",
@ -219,9 +245,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.find.seedSearchStringFromSelection.never": "Asla düzenleyici seçiminden arama dizesi çekirdeği oluşturma.",
"editor.find.seedSearchStringFromSelection.selection": "Sadece düzenleyici seçiminden arama dizesi çekirdeği oluştur.",
"editor.gotoLocation.multiple.deprecated": "Bu ayar kullanım dışı. Bunun yerine lütfen 'editor.editor.gotoLocation.multipleDefinitions' veya 'editor.editor.gotoLocation.multipleImplementations' gibi ayrı ayarları kullanın.",
"editor.gotoLocation.multiple.goto": "Birincil sonuca git ve diğerlerinde göz atmasız gezintiyi etkinleştir",
"editor.gotoLocation.multiple.gotoAndPeek": "Birincil sonuca git ve göz atma görünümü göster",
"editor.gotoLocation.multiple.peek": "Sonuçların göz atma görünümünü göster (varsayılan)",
"editor.gotoLocation.multiple.goto": "Birincil sonuca gidin ve diğerlerine Peek'siz gezinmeyi etkinleştirin",
"editor.gotoLocation.multiple.gotoAndPeek": "Birincil sonuca gidin ve bir Peek görünümü gösterin",
"editor.gotoLocation.multiple.peek": "Sonuçların Peek görünümünü göster (varsayılan)",
"editor.guides.bracketPairs": "Köşeli ayraç çifti kılavuzlarının etkinleştirilip etkinleştirilmediklerini denetler.",
"editor.guides.bracketPairs.active": "Yalnızca etkin köşeli ayraç çifti için köşeli ayraç çifti kılavuzlarını etkinleştirir.",
"editor.guides.bracketPairs.false": "Köşeli ayraç çifti kılavuzlarını devre dışı bırakır.",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "Dikey köşeli ayraç çifti kılavuzlarına ek olarak yatay kılavuzları etkinleştirir.",
"editor.guides.highlightActiveBracketPair": "Düzenleyicinin etkin köşeli ayraç çiftini vurgulayıp vurgulamayacağını kontrol eder.",
"editor.guides.highlightActiveIndentation": "Düzenleyicinin etkin girinti kılavuzunu vurgulayıp vurgulamayacağını denetler.",
"editor.guides.highlightActiveIndentation.always": "Köşeli ayraç kılavuzları vurgulanmış olsa bile etkin girinti kılavuzunu vurgular.",
"editor.guides.highlightActiveIndentation.false": "Etkin girinti kılavuzunu vurgulama.",
"editor.guides.highlightActiveIndentation.true": "Etkin girinti kılavuzunu vurgular.",
"editor.guides.indentation": "Düzenleyicinin girinti kılavuzlarını işleyip işlemeyeceğini denetler.",
"editor.inlayHints.off": "Yerleşik ipuçları devre dışı bırakıldı",
"editor.inlayHints.offUnlessPressed": "Yerleşik ipuçları varsayılan olarak gizlidir ve {0} basılıyken gösterilir",
"editor.inlayHints.on": "Yerleşik ipuçları etkinleştirildi",
"editor.inlayHints.onUnlessPressed": "Yerleşik ipuçları varsayılan olarak gösterilir ve {0} basılıyken gizlenir",
"editor.stickyScroll": "Düzenleyicinin üst kısmındaki kaydırma sırasında iç içe geçmiş geçerli kapsamları gösterir.",
"editor.stickyScroll.": "Gösterilecek en fazla yapışkan satır sayısını tanımlar.",
"editor.suggest.matchOnWordStartOnly": "Etkinleştirildiğinde, IntelliSense filtreleme, ilk karakterin bir kelime başlangıcında eşleşmesini gerektirir, örneğin `Console` veya `WebContext` üzerindeki `c` ancak `description` üzerinde değil. Devre dışı bırakıldığında, IntelliSense daha fazla sonuç gösterir ancak yine de bunları eşleşme kalitesine göre sıralar.",
"editor.suggest.showClasss": "Etkinleştirildiğinde, IntelliSense 'class' önerilerini gösterir.",
"editor.suggest.showColors": "Etkinleştirildiğinde, IntelliSense 'color' önerilerini gösterir.",
"editor.suggest.showConstants": "Etkinleştirildiğinde, IntelliSense 'constant' önerilerini gösterir.",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "Etkinleştirildiğinde, IntelliSense 'variable' önerilerini gösterir.",
"editorViewAccessibleLabel": "Düzenleyici içeriği",
"emptySelectionClipboard": "Seçmeden kopyalamanın geçerli satırı mı kopyalayacağını denetler.",
"experimentalWhitespaceRendering": "Boşluğun yeni, deneysel metotla işlenip işlenmeyeceğini belirler.",
"experimentalWhitespaceRendering.font": "Yazı tipi karakterlerini içeren yeni işleme yöntemini kullanın.",
"experimentalWhitespaceRendering.off": "Kararlı işleme yöntemini kullanın.",
"experimentalWhitespaceRendering.svg": "SVG'lerle yeni bir işleme yöntemi kullanın.",
"fastScrollSensitivity": "`Alt` tuşuna basılırken kaydırma hızı çarpanı.",
"find.addExtraSpaceOnTop": "Bulma Pencere Öğesinin düzenleyicinin en üstüne ek satırlar ekleyip eklemeyeceğini denetler. Değeri true olduğunda, Bulma Pencere Öğesi görünürken ekranı ilk satırın ötesine kaydırabilirsiniz.",
"find.autoFindInSelection": "Seçimde Bul özelliğini otomatik olarak açmak için koşulu denetler.",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "Yazı tipi ligatürleri ('calt' ve 'liga' yazı tipi özellikleri) etkinleştirir/devre dışı bırakır. 'font-feature-settings' CSS özelliğinin ayrıntılı denetimi için bunu bir dizeye çevirin.",
"fontLigaturesGeneral": "Yazı tipi ligatürleri veya yazı tipi özelliklerini yapılandırır. Ligatürleri etkinleştirmek/devre dışı bırakmak için boole veya CSS 'font-feature-settings' özelliğinin değeri için dize olabilir.",
"fontSize": "Piksel cinsinden yazı tipi boyutunu denetler.",
"fontVariationSettings": "Açık 'font-variation-settings' CSS özelliği. Yalnızca font-weight ile font-variation-settings arası çeviri gerekiyorsa bunun yerine bir boole değeri geçirilebilir.",
"fontVariations": "Çeviriyi font-weight ayarından font-variation-settings ayarına Etkinleştirir/Devre Dışı Bırakır. 'font-variation-settings' CSS özelliğinin ayrıntılı denetimi için bunu bir dize olarak değiştirin.",
"fontVariationsGeneral": "Yazı tipi çeşitlemelerini yapılandırır. Font-weight ile font-variation-settings arası çeviriyi etkinleştirmek/devre dışı bırakmak için boole değeri veya CSS 'font-variation-settings' özelliğinin değeri için bir dize olabilir.",
"fontWeight": "Yazı tipi kalınlığını denetler. \"normal\" ve \"bold\" anahtar sözcüklerini ya da 1 ile 1000 arasında sayıları kabul eder.",
"fontWeightErrorMessage": "Yalnızca \"normal\" ve \"bold\" anahtar sözcükleri veya 1 ile 1000 arasında sayılar kullanılabilir.",
"formatOnPaste": "Düzenleyicinin yapıştırılan içeriği otomatik olarak biçimlendirip biçimlendirmeyeceğini denetler. Bir biçimlendirici kullanılabilir olmalı ve belgedeki bir aralığı biçimlendirebilmelidir.",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "Vurgulamanın gösterilip gösterilmeyeceğini denetler.",
"hover.sticky": "Fare ile üzerine gelindiğinde vurgulamanın görünür kalıp kalmayacağını denetler.",
"inlayHints.enable": "Düzenleyicideki dolgu ipuçlarını etkinleştirir.",
"inlayHints.fontFamily": "Düzenleyicideki dolgu ipuçlarının yazı tipi boyutunu denetler. Boş olarak ayarlandığında, ‘#editor.fontSize#’ değeri kullanılır.",
"inlayHints.fontSize": "Düzenleyicideki dolgu ipuçlarının yazı tipi boyutunu. Yapılandırılan değer `5`ten küçük veya düzenleyici yazı tipi boyutundan büyük olduğunda varsayılan olarak \"#editor.fontSize#\" değerinin %90'ı kullanılır.",
"inlayHints.fontFamily": "Düzenleyicideki dolgu ipuçlarının yazı tipi boyutunu denetler. Boş olarak ayarlandığında {0} değeri kullanılır.",
"inlayHints.fontSize": "Düzenleyicideki yerleşik ipuçlarının yazı tipi boyutunu denetler. Ayarlanan değer{1} rakamından küçük veya düzenleyici yazı tipi boyutundan büyükse, varsayılan olarak {0} kullanılır.",
"inlayHints.padding": "Düzenleyicideki yerleşik ipuçları çevresindeki doldurmayı etkinleştirir.",
"inline": "Hızlı öneriler hayalet metin olarak görünür",
"inlineSuggest.enabled": "Satır içi önerilerin düzenleyicide otomatik olarak gösterilip gösterilmeyeceğini denetler.",
"inlineSuggest.showToolbar": "Satır içi öneri araç çubuğunun ne zaman gösterileceğini denetler.",
"inlineSuggest.showToolbar.always": "Ne zaman bir satır içi öneri gösterilirse satır içi öneri araç çubuğunu göster.",
"inlineSuggest.showToolbar.onHover": "Bir satır içi önerinin üzerine gelindiğinde satır içi öneri araç çubuğunu göster.",
"letterSpacing": "Piksel cinsinden harf aralığını denetler.",
"lineHeight": "Satır yüksekliğini kontrol eder. \r\n - Satır yüksekliğini yazı tipi boyutundan otomatik olarak hesaplamak için 0 değerini kullanın.\r\n - 0 ile 8 arasındaki değerler, yazı tipi boyutuyla çarpan olarak kullanılır.\r\n - 8 ve daha büyük değerler etkin değerler olarak kullanılır.",
"lineNumbers": "Satır numaralarının görüntülenmesini denetler.",
@ -305,9 +352,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"lineNumbers.off": "Satır numaraları işlenmez.",
"lineNumbers.on": "Satır numaraları mutlak sayı olarak oluşturulur.",
"lineNumbers.relative": "Satır numaraları imlecin bulunduğu konuma satır cinsinden uzaklık olarak oluşturulur.",
"linkedEditing": "Düzenleyicide bağlı düzenlemenin etkin olup olmadığını denetler. İlgili semboller (ör. HTML etiketleri) düzenleme sırasında dile bağlı olarak güncelleştirilir.",
"linkedEditing": "Düzenleyicinin bağlantılı düzenlemeyi etkinleştirip etkinleştirmediğini kontrol eder. Dile bağlı olarak, HTML etiketleri gibi ilgili semboller düzenleme sırasında güncellenir.",
"links": "Düzenleyicinin bağlantıları algılayıp tıklanabilir yapıp yapmayacağını denetler.",
"matchBrackets": "Eşleşen ayraçları vurgula.",
"minimap.autohide": "Mini haritanın otomatik olarak gizlenip gizlenmediğini kontrol eder.",
"minimap.enabled": "Mini haritanın gösterilip gösterilmeyeceğini denetler.",
"minimap.maxColumn": "Mini haritanın genişliğini belirli sayıda sütuna kadar işlenecek şekilde sınırlayın.",
"minimap.renderCharacters": "Satırdaki renk blokları yerine gerçek karakterleri işleyin.",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "Mini harita, düzenleyici içeriğiyle aynı boyuta sahip olur (ve kaydırılabilir).",
"mouseWheelScrollSensitivity": "Fare tekerleği kaydırma olaylarının 'deltaX' ve 'deltaY' değerleri üzerinde kullanılacak çarpan.",
"mouseWheelZoom": "`Ctrl` tuşuna basarken fare tekerleği kullanıldığında düzenleyicinin yazı tipini yakınlaştırın.",
"multiCursorLimit": "Etkin bir düzenleyicide aynı anda olabilecek azami imleç sayısını kontrol eder.",
"multiCursorMergeOverlapping": "Örtüşen birden çok imleci birleştirin.",
"multiCursorModifier": "Fareyle birden çok imleç eklemek için kullanılacak değiştirici. Tanıma Git ve Bağlantıyı Aç fare hareketleri, çok imleçli değiştirici ile çakışmayacak şekilde uyarlanır. [Daha fazla bilgi](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier).",
"multiCursorModifier": "Fareyle birden çok imleç eklemek için kullanılacak değiştirici. Tanıma Git ve Bağlantıyı Aç fare hareketleri, [çok imleçli değiştirici](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier) ile çakışmayacak şekilde uyarlanır.",
"multiCursorModifier.alt": "Windows ve Linux'ta `Alt`, macOS'te `Option` tuşuna eşlenir.",
"multiCursorModifier.ctrlCmd": "Windows ve Linux'ta `Control`, macOS'te `Command` tuşuna eşlenir.",
"multiCursorPaste": "Yapıştırılan metnin satır sayısı imleç sayısıyla eşleştiğinde yapıştırmayı denetler.",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "Satır içi düzenleyicinin veya ağacın göz atma pencere öğesine odaklanıp odaklanmayacağını denetler.",
"peekWidgetDefaultFocus.editor": "Göz atmayı açarken düzenleyiciyi odakla",
"peekWidgetDefaultFocus.tree": "Göz atmayı açarken ağacı odakla",
"quickSuggestions": "Yazma sırasında önerilerin otomatik olarak gösterilip gösterilmeyeceğini denetler.",
"quickSuggestions": "Yazarken önerilerin otomatik olarak görünüp görünmeyeceğini denetler. Bu; açıklamalar, dizeler ve diğer kodlarda yazmak için denetlenebilir. Hızlı öneri, hayalet metin olarak veya öneri pencere öğesiyle gösterilecek şekilde yapılandırılabilir. Ayrıca, önerilerin özel karakterlerle tetiklenip tetiklenmeyeceğini denetleyen '{0}' ayarına da dikkat edin.",
"quickSuggestions.comments": "Açıklamaların içinde hızlı önerileri etkinleştirin.",
"quickSuggestions.other": "Dizelerin ve açıklamaların dışında hızlı önerileri etkinleştirin.",
"quickSuggestions.strings": "Dizelerin içinde hızlı önerileri etkinleştirin.",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "Cilt paylarında katlama denetimlerinin ne zaman gösterileceğini denetler.",
"showFoldingControls.always": "Her zaman katlama denetimlerini göster.",
"showFoldingControls.mouseover": "Katlama denetimlerini yalnızca fare cilt payı üzerindeyken göster.",
"showFoldingControls.never": "Katlama denetimlerini hiçbir zaman gösterme ve cilt payı boyutunu küçültme.",
"showUnused": "Kullanılmayan kodun soluklaştırılmasını denetler.",
"smoothScrolling": "Düzenleyicinin bir animasyon kullanılarak mı kaydırılacağını denetler.",
"snippetSuggestions": "Kod parçacıklarının başka öneriler ile birlikte mi gösterileceğini ve nasıl sıralanacağını denetler.",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "Girintileme için boşluklar kullanılırken sekme karakterlerinin seçim davranışına öykünün. Seçim, sekme duraklarına göre uygulanır.",
"suggest.filterGraceful": "Küçük yazım hatalarının nedeninin filtreleme ve sıralama önerileri olup olmadığını denetler.",
"suggest.insertMode": "Tamamlamalar kabul edilirken sözcüklerin üzerine yazılıp yazılmadığını denetler. Bunun bu özelliği kullanmayı kabul eden uzantılara bağlı olduğunu unutmayın.",
"suggest.insertMode.always": "IntelliSense'i otomatik olarak tetiklerken her zaman bir öneri seçin.",
"suggest.insertMode.insert": "Öneriyi imlecin sağındaki metnin üzerine yazmadan ekle.",
"suggest.insertMode.never": "IntelliSense'i otomatik olarak tetiklerken hiçbir zaman öneri seçme.",
"suggest.insertMode.replace": "Öneriyi ekle ve imlecin sağındaki metnin üzerine yaz.",
"suggest.insertMode.whenQuickSuggestion": "Yalnızca siz yazdıkça IntelliSense'i tetiklerken bir öneri seçin.",
"suggest.insertMode.whenTriggerCharacter": "Bir öneriyi yalnızca IntelliSense'i bir tetikleyici karakterden tetiklerken seçin.",
"suggest.localityBonus": "Sıralamanın imlecin yakındaki sözcüklere öncelik verip vermeyeceğini denetler.",
"suggest.maxVisibleSuggestions.dep": "Bu ayar kullanım dışı bırakıldı. Öneri pencere öğesi artık yeniden boyutlandırılabilir.",
"suggest.preview": "Öneri sonucunun düzenleyicide önizlenip önizlenmeyeceğini denetler.",
"suggest.selectionMode": "Pencere öğesi gösterildiğinde bir önerinin seçilip seçilmediğini kontrol eder. Bunun yalnızca otomatik olarak tetiklenen öneriler ('#editor.quickSuggestions#' ve '#editor.suggestOnTriggerCharacters#') için geçerli olduğunu ve bir önerinin her zaman açıkça çağrıldığında (ör. 'Ctrl+Space' aracılığıyla) seçili olduğunu unutmayın.",
"suggest.shareSuggestSelections": "Hatırlanan öneri seçimlerinin birden çok çalışma alanı ve pencere arasında paylaşılıp paylaşılmayacağını denetler (`#editor.suggestSelection#` gerekir).",
"suggest.showIcons": "Önerilerde simge gösterme veya gizlemeyi denetler.",
"suggest.showInlineDetails": "Öneri ayrıntılarının, etiketle satır içi olarak mı, yoksa yalnızca ayrıntılar pencere öğesinde mi gösterileceğini denetler",
"suggest.showInlineDetails": "Öneri ayrıntılarının etiketle aynı hizada mı yoksa yalnızca ayrıntılar pencere öğesinde mi gösterileceğini kontrol eder.",
"suggest.showStatusBar": "Önerilen pencere öğesinin en altındaki durum çubuğunun görünürlüğünü denetler.",
"suggest.snippetsPreventQuickSuggestions": "Etkin bir kod parçacığının hızlı önerilere engel olup olmayacağını denetler.",
"suggestFontSize": "Önerilen pencere öğesi için yazı tipi boyutu. '0' olarak ayarlandığında '#editor.fontSize#' değeri kullanılır.",
"suggestLineHeight": "Öneri pencere öğesi için satır yüksekliği. `0` olarak ayarlandığında `#editor.lineHeight#` değeri kullanılır. En küçük değer 8'dir.",
"suggestFontSize": "Önerilen pencere öğesi için yazı tipi boyutu. {0} olarak ayarlandığında {1} değeri kullanılır.",
"suggestLineHeight": "Önerilen pencere öğesi için satır yüksekliği. {0} olarak ayarlandığında {1} değeri kullanılır. En küçük değer 8'dir.",
"suggestOnTriggerCharacters": "Tetikleyici karakterleri yazılırken önerilerin otomatik olarak gösterilip gösterilmeyeceğini denetler.",
"suggestSelection": "Öneri listesi gösterilirken önerilerin önceden nasıl seçileceğini denetler.",
"suggestSelection.first": "Her zaman ilk öneriyi seç.",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "Sekmeyle tamamlamaları devre dışı bırak.",
"tabCompletion.on": "Sekmeyle tamamlama, sekme tuşuna basıldığında en iyi eşleşen öneriyi ekler.",
"tabCompletion.onlySnippets": "Ön eki eşleştiğinde kod parçacığını sekmeyle tamamla. 'quickSuggestions' etkinleştirilmediğinde en iyi sonucu verir.",
"tabFocusMode": "Düzenleyicinin sekmeleri alıp almayacağını veya bunları gezinti için workbench’e erteleyip ertelemediğini denetler.",
"unfoldOnClickAfterEndOfLine": "Katlanmış bir satırdan sonraki boş içeriğe tıklamanın katlamayı açıp açmayacağını denetler.",
"unicodeHighlight.allowedCharacters": "Vurgulanmamış, izin verilmiş karakterleri tanımlar.",
"unicodeHighlight.allowedLocales": "İzin verilen yerel ayarlarda yaygın olan Unicode karakterler vurgulanmıyor.",
"unicodeHighlight.ambiguousCharacters": "Geçerli kullanıcı yerel ayarında yaygın olan karakterler dışında, temel ASCII karakterleriyle karıştırılabilecek karakterlerin vurgulanmış olup olmadığını kontrol eder.",
"unicodeHighlight.includeComments": "Yorumlardaki karakterlerin unicode vurgusuna da tabi olup olmamasını denetler.",
"unicodeHighlight.includeStrings": "Dizelerdeki karakterlerin unicode vurgusuna da tabi olup olmamasını denetler.",
"unicodeHighlight.includeComments": "Yorumlardaki karakterlerin de Unicode vurgulamasına tabi olup olmayacağını kontrol eder.",
"unicodeHighlight.includeStrings": "Dizelerdeki karakterlerin de Unicode vurgulamasına tabi olup olmayacağını kontrol eder.",
"unicodeHighlight.invisibleCharacters": "Yalnızca boşluk tutan veya genişliği olmayan karakterlerin vurgulanmış olup olmadığını kontrol eder.",
"unicodeHighlight.nonBasicASCII": "Temel olmayan tüm ASCII karakterlerinin vurgulanmış olup olmadığını kontrol eder. Yalnızca U+0020 ile U+007E arasındaki karakterler, sekme, satır ilerletme ve satır başı karakterleri temel ASCII olarak kabul edilir.",
"unusualLineTerminators": "Soruna neden olabilecek olağan dışı satır sonlandırıcıları kaldır.",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "Olağan dışı satır sonlandırıcılar yoksayılır.",
"unusualLineTerminators.prompt": "Olağan dışı satır sonlandırıcıların kaldırılması sorulur.",
"useTabStops": "Boşluk ekleme ve silme sekme duraklarını izler.",
"wordBreak": "Çince/Japonca/Korece (CJK) metinlerde kullanılan sözcük kesme kurallarını kontrol eder.",
"wordBreak.keepAll": "Çince/Japonca/Korece (CJK) metinlerde sözcük kesme kullanılmamalıdır. CJK olmayan metin davranışı normalle aynıdır.",
"wordBreak.normal": "Varsayılan satır sonu kuralını kullanın.",
"wordSeparators": "Sözcüklerle ilgili gezintiler veya işlemler yapılırken sözcük ayracı olarak kullanılacak karakterler.",
"wordWrap": "Satırların nasıl kaydırılacağını denetler.",
"wordWrap.bounded": "Satırlar görünüm penceresi ile `#editor.wordWrapColumn#` değerlerinin daha küçük olanında kaydırılır.",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "Kaydırılan satırlar üst öğeye doğru +1 girinti alır.",
"wrappingIndent.none": "Girinti yok. Kaydırılan satırlar 1. sütundan başlar.",
"wrappingIndent.same": "Kaydırılan satırlar üst öğeyle aynı girintiyi alır.",
"wrappingStrategy": "Kaydırma noktalarını hesaplayan algoritmayı denetler.",
"wrappingStrategy": "Kaydırma noktalarını hesaplayan algoritmayı kontrol eder. Erişilebilirlik modundayken, en iyi deneyim için gelişmişin kullanılacağını unutmayın.",
"wrappingStrategy.advanced": "Kaydırma noktaları hesaplamasını tarayıcıya devreder. Bu yavaş bir algoritmadır ve büyük dosyaların donmasına neden olabilir, ancak tüm durumlarda doğru şekilde çalışır.",
"wrappingStrategy.simple": "Tüm karakterlerin aynı genişlikte olduğunu varsayar. Bu, tek aralıklı yazı tiplerinde ve karakterlerin eşit genişlikte olduğu belirli betiklerde (Latince karakterler gibi) doğru şekilde çalışan hızlı bir algoritmadır."
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "Etkin olmayan köşeli ayraç çifti kılavuzlarının arka plan rengi (6). Köşeli ayraç çifti kılavuzlarının etkinleştirilmesini gerektirir.",
"editorCodeLensForeground": "Düzenleyici CodeLens'inin ön plan rengi",
"editorCursorBackground": "Düzenleyici imlecinin arka plan rengi. Bir blok imleç ile örtüşen bir karakterin rengini özelleştirmeye izin verir.",
"editorDimmedLineNumber": "editor.renderFinalNewline soluk olarak ayarlandığında son düzenleyici çizgisinin rengi.",
"editorGhostTextBackground": "Düzenleyicideki soluk metnin arka plan rengi.",
"editorGhostTextBorder": "Düzenleyicideki soluk metnin kenarlık rengi.",
"editorGhostTextForeground": "Düzenleyicideki soluk metnin ön plan rengi.",
"editorGutter": "Düzenleyici cilt payının arka plan rengi. Cilt payı, karakter kenar boşluklarını ve satır numaralarını içerir.",
"editorIndentGuides": "Düzenleyici girinti kılavuzlarının rengi.",
"editorLineNumbers": "Düzenleyici satır numaralarının rengi.",
"editorOverviewRulerBackground": "Düzenleyiciye genel bakış cetvelinin arka plan rengi. Yalnızca mini harita etkinleştirilip düzenleyicinin sağ tarafına yerleştirildiğinde kullanılır.",
"editorOverviewRulerBackground": "Düzenleyici genel bakış cetveli arka plan rengi.",
"editorOverviewRulerBorder": "Genel bakış cetveli kenarlığının rengi.",
"editorRuler": "Düzenleyici cetvellerinin rengi.",
"editorUnicodeHighlight.background": "Unicode karakterleri vurgulamak için kullanılan arka plan rengi.",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "Geçerli düzenleyicide Sekme tuşuna basmak, odağı bir sonraki odaklanılabilir öğeye taşır. {0} komutu şu anda bir tuş bağlaması tarafından tetiklenebilir durumda değil.",
"toggleHighContrast": "Yüksek Karşıtlık Temasını Aç/Kapat"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} karakter",
"showMore": "Daha fazla göster ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "Bağlayıcı {0}:{1} konumuna kondu",
"cancelSelectionAnchor": "Seçim Bağlayıcısını İptal Et",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "Farklı Kopyala",
"miCopy": "&&Kopyala",
"miCut": "&&Kes",
"miPaste": "&&Yapıştır"
"miPaste": "&&Yapıştır",
"share": "Paylaş"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "Kod eylemi uygulanırken bilinmeyen bir hata oluştu"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "Kod eylemi uygulanırken bilinmeyen bir hata oluştu",
"args.schema.apply": "Döndürülen eylemlerin ne zaman uygulanacağını denetler.",
"args.schema.apply.first": "İlk döndürülen kod eylemini her zaman uygula.",
"args.schema.apply.ifSingle": "İlk kod eylemi döndürülen tek eylem ise uygula.",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "İçeri Aktarmaları Düzenle",
"quickfix.trigger.label": "Hızlı Düzeltme...",
"refactor.label": "Yeniden düzenle...",
"refactor.preview.label": "Önizleme ile yeniden düzenleme...",
"source.label": "Kaynak Eylemi..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "Kod Eylemi menüsünde grup başlıklarının gösterilmesini etkinleştirin/devre dışı bırakın."
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "Yeniden Yazın...",
"codeAction.widget.id.extract": "Ayıkla...",
"codeAction.widget.id.inline": "Satır içi",
"codeAction.widget.id.more": "Diğer Eylemler...",
"codeAction.widget.id.move": "Taşı...",
"codeAction.widget.id.quickfix": "Hızlı Düzeltme...",
"codeAction.widget.id.source": "Kaynak Eylemi...",
"codeAction.widget.id.surround": "Şununla Çevrele..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "Devre Dışı Olanları Gizle",
"showMoreActions": "Devre Dışı Olanları Göster"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "Kod Eylemlerini Göster",
"codeActionWithKb": "Kod Eylemlerini Göster ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "&&Satır Açıklamasını Aç/Kapat"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "Düzenleyici Bağlam Menüsünü Göster"
"action.showContextMenu.label": "Düzenleyici Bağlam Menüsünü Göster",
"context.minimap.minimap": "Mini Harita",
"context.minimap.renderCharacters": "Karakterleri İşle",
"context.minimap.size": "Dikey boyut",
"context.minimap.size.fill": "Doldur",
"context.minimap.size.fit": "Sığdır",
"context.minimap.size.proportional": "Orantılı",
"context.minimap.slider": "Kaydırıcı",
"context.minimap.slider.always": "Her zaman",
"context.minimap.slider.mouseover": "Fareyle Üzerine Gelin"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "Yapıştırma sırasında uzantılardan düzenleme çalıştırmayı etkinleştir/devre dışı bırak."
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "Yapıştırma işleyicileri çalıştırılıyor..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "İmleç Yineleme",
"cursor.undo": "İmleç Geri Alma"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "Bırakma işleyicileri çalıştırılıyor..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "Düzenleyicinin iptal edilebilir bir işlem (ör. 'Başvurulara Göz Atma' gibi) çalıştırıp çalıştırmayacağını belirtir"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "\"Matematik Harfleri\" bayrağını geçersiz kılar.\r\nBayrak gelecek için kaydedilmez.\r\n0: Hiçbir Şey Yapma\r\n1: True\r\n2: Yanlış",
"actions.find.preserveCaseOverride": "\"Büyük/Küçük Harf Koru\" bayrağını geçersiz kılar.\r\nBayrak gelecek için kaydedilmez.\r\n0: Hiçbir Şey Yapma\r\n1: True\r\n2: Yanlış",
"actions.find.wholeWordOverride": "\"Tüm Sözcüğü Eşleştir\" bayrağını geçersiz kılar.\r\nBayrak gelecek için kaydedilmez.\r\n0: Hiçbir Şey Yapma\r\n1: True\r\n2: False",
"findMatchAction.goToMatch": "Eşleşmeye git...",
"findMatchAction.inputPlaceHolder": "Belirli bir eşleşmeye gitmek için bir sayı yazın (1 ile {0}arasında)",
"findMatchAction.inputValidationMessage": "Lütfen 1 ile {0} arasında bir sayı girin",
"findNextMatchAction": "Sonrakini Bul",
"findPreviousMatchAction": "Öncekini Bul",
"miFind": "&&Bul",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "Yalnızca ilk {0} sonuç vurgulanır, ancak tüm bulma işlemleri metnin tamamında sonuç verir."
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "Düzenleyici cilt payı içindeki katlama denetiminin rengi.",
"createManualFoldRange.label": "Seçimden Katlama Aralığı Oluştur",
"foldAction.label": "Katla",
"foldAllAction.label": "Tümünü Katla",
"foldAllBlockComments.label": "Tüm Blok Açıklamaları Katla",
"foldAllExcept.label": "Seçili Bölgeler Hariç Tüm Bölgeleri Katla",
"foldAllMarkerRegions.label": "Tüm Bölgeleri Katla",
"foldBackgroundBackground": "Katlanan aralıkların arka plan rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"foldLevelAction.label": "Katlama Düzeyi {0}",
"foldRecursivelyAction.label": "Özyinelemeli Katla",
"gotoNextFold.label": "Sonraki Katlama Aralığına Git",
"gotoParentFold.label": "Üst Katlamaya Git",
"gotoPreviousFold.label": "Önceki Katlama Aralığına Git",
"maximum fold ranges": "Katlanabilir bölgelerin sayısı maksimum {0} ile sınırlıdır. Daha fazlasını etkinleştirmek için ['Maksimum Bölgeleri Katlama'](command:workbench.action.openSettings?[\" editor.foldingMaximumRegions\"]) yapılandırma seçeneğini kullanın.",
"removeManualFoldingRanges.label": "El ile Katlama Aralıklarını Kaldır",
"toggleFoldAction.label": "Katlamayı Aç/Kapat",
"unFoldRecursivelyAction.label": "Katlamayı Özyinelemeli Olarak Kaldır",
"unfoldAction.label": "Katlamayı Kaldır",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "Tüm Bölgelerin Katlamasını Kaldır"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "Düzenleyici cilt payı içindeki katlama denetiminin rengi.",
"foldBackgroundBackground": "Katlanan aralıkların arka plan rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"foldingCollapsedIcon": "Düzenleyici karakter dış boşluğundaki daraltılmış aralıklar simgesi.",
"foldingExpandedIcon": "Düzenleyici karakter dış boşluğundaki genişletilmiş aralıklar simgesi."
"foldingExpandedIcon": "Düzenleyici karakter dış boşluğundaki genişletilmiş aralıklar simgesi.",
"foldingManualCollapedIcon": "Düzenleyici karakter dış boşluğunda el ile daraltılmış aralıklar simgesi.",
"foldingManualExpandedIcon": "Düzenleyici karakter dış boşluğunda el ile genişletilmiş aralıklar simgesi."
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "Düzenleyici Yazı Tipini Yakınlaştır",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "Yükleniyor...",
"stopped rendering": "İşleme, performansla ilgili nedenlerden dolayı uzun satır için duraklatıldı. Bu, 'editor.stopRenderingLineAfter' aracılığıyla yapılandırılabilir.",
"too many characters": "Performans nedeniyle uzun satırlar için belirteç oluşturma atlandı. Bu `editor.maxTokenizationLineLength` ile yapılandırılabilir."
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "Sorunu Göster"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "Sekme Görüntüleme Boyutunu Değiştir",
"configuredTabSize": "Yapılandırılan Sekme Boyutu",
"currentTabSize": "Geçerli Sekme Boyutu",
"defaultTabSize": "Varsayılan Sekme Boyutu",
"detectIndentation": "Girintiyi İçerikten Algıla",
"editor.reindentlines": "Satırları Yeniden Girintile",
"editor.reindentselectedlines": "Seçili Satırları Yeniden Girintile",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd + tıklama"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "Kabul et",
"acceptWord": "Word'ü Kabul Et",
"action.inlineSuggest.accept": "Satır İçi Öneriyi Kabul Et",
"action.inlineSuggest.acceptNextWord": "Sonraki Satır İçi Öneri Kelimesini Kabul Et",
"action.inlineSuggest.alwaysShowToolbar": "Araç Çubuğunu Her Zaman Göster",
"action.inlineSuggest.hide": "Satır İçi Öneriyi Gizle",
"action.inlineSuggest.showNext": "Sonraki Satır İçi Öneriyi Göster",
"action.inlineSuggest.showPrevious": "Önceki Satır İçi Öneriyi Göster",
"action.inlineSuggest.trigger": "Satır İçi Öneriyi Tetikle",
"action.inlineSuggest.undo": "Word'ü Kabul Etme İşlemini Geri Al",
"alwaysShowInlineSuggestionToolbar": "Satır içi öneri araç çubuğunun her zaman görünür olup olmayacağı",
"canUndoInlineSuggestion": "Geri alma işleminin satır içi öneriyi geri alıp almayacağı",
"inlineSuggestionHasIndentation": "Satır içi önerinin boşlukla başlayıp başlamadığını belirtir",
"inlineSuggestionHasIndentationLessThanTabSize": "Satır içi önerinin, sekme tarafından eklenecek olandan daha az olan boşlukla başlayıp başlamadığı",
"inlineSuggestionVisible": "Satır içi önerinin görünür olup olmadığını belirtir"
"inlineSuggestionVisible": "Satır içi önerinin görünür olup olmadığını belirtir",
"undoAcceptWord": "Word'ü Kabul Etme İşlemini Geri Al"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "Öneri:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "Sonraki",
"parameterHintsNextIcon": "Sonraki parametre ipucunu göster simgesi.",
"parameterHintsPreviousIcon": "Önceki parametre ipucunu göster simgesi.",
"previous": "Önceki"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "Sonraki Değerle Değiştir",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "Seçimi Çoğalt",
"editor.transformToCamelcase": "Orta Harfi Büyük Olan Sözcüklere Dönüştür",
"editor.transformToKebabcase": "kebab-case’e Dönüştür",
"editor.transformToLowercase": "Küçük Harfe Dönüştür",
"editor.transformToSnakecase": "Snake Case'e Dönüştür",
"editor.transformToTitlecase": "İlk Harfleri Büyüt",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "{0} komutunu yürütün"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "Salt okunur düzenleyicide düzenleme yapılamaz",
"messageVisible": "Düzenleyicinin şu anda bir satır içi ileti gösterip göstermediğini belirtir"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "Son Seçimi Önceki Bulma Eşleştirmesine Taşı",
"mutlicursor.addCursorsToBottom": "İmleçleri Alta Ekle",
"mutlicursor.addCursorsToTop": "İmleçleri Üste Ekle",
"mutlicursor.focusNextCursor": "Sonraki İmleci Odakla",
"mutlicursor.focusNextCursor.description": "Sonraki imleci odaklar",
"mutlicursor.focusPreviousCursor": "Önceki İmleci Odakla",
"mutlicursor.focusPreviousCursor.description": "Önceki imleci odaklar",
"mutlicursor.insertAbove": "Yukarıya İmleç Ekle",
"mutlicursor.insertAtEndOfEachLineSelected": "İmleçleri Satır Sonlarına Ekle",
"mutlicursor.insertBelow": "Aşağıya İmleç Ekle",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "Göz atma görünümü düzenleyicisindeki cilt payının arka plan rengi.",
"peekViewEditorMatchHighlight": "Göz atma görünümü düzenleyicisindeki eşleşme vurgusu rengi.",
"peekViewEditorMatchHighlightBorder": "Göz atma görünümü düzenleyicisindeki eşleşme vurgusu kenarlığı.",
"peekViewEditorStickScrollBackground": "Göz atma görünümü düzenleyicisindeki yapışkan kaydırmanın arka plan rengi.",
"peekViewResultsBackground": "Göz atma görünümü sonuç listesinin arka plan rengi.",
"peekViewResultsFileForeground": "Göz atma görünümü sonuç listesinde dosya düğümleri için ön plan rengi.",
"peekViewResultsMatchForeground": "Göz atma görünümü sonuç listesinde satır düğümleri için ön plan rengi.",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "tür parametreleri ({0})",
"variable": "değişkenler ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "Salt okunur düzenleyicide düzenleme yapılamaz",
"editor.simple.readonly": "Salt okunur girişte düzenleme yapılamaz"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "'{0}', '{1}' olarak başarıyla yeniden adlandırıldı. Özel: {2}",
"enablePreview": "Yeniden adlandırmadan önce değişiklikleri önizleme olanağını etkinleştir/devre dışı bırak",
"label": "'{0}' yeniden adlandırılıyor",
"label": "'{0}', '{1}' olarak yeniden adlandırılıyor",
"no result": "Sonuç yok.",
"quotableLabel": "{0} yeniden adlandırılıyor",
"quotableLabel": "{0}, {1} olarak yeniden adlandırılıyor",
"rename.failed": "Yeniden adlandırma, düzenlemeleri hesaplayamadı",
"rename.failedApply": "Yeniden adlandırma, düzenlemeleri uygulayamadı",
"rename.label": "Sembolü Yeniden Adlandır",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "Kod parçacığı modundayken sonraki sekme durağının olup olmadığını belirtir",
"hasPrevTabstop": "Kod parçacığı modundayken önceki sekme durağının olup olmadığını belirtir",
"inSnippetMode": "Düzenleyicinin şu anda parçacık modunda olup olmadığını belirtir"
"inSnippetMode": "Düzenleyicinin şu anda parçacık modunda olup olmadığını belirtir",
"next": "Sonraki yer tutucuya git..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "Nisan",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "Çarşamba",
"WednesdayShort": "Çar"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "&&Yapışkan Kaydırma",
"mitoggleStickyScroll": "Yapışkan Kaydırmayı &&Aç/Kapat",
"stickyScroll": "Yapışkan Kaydırma",
"toggleStickyScroll": "Yapışkan Kaydırmayı Aç/Kapat"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "Enter tuşuna basıldığında önerilerin eklenip eklenmeyeceğini belirtir",
"suggestWidgetDetailsVisible": "Öneri ayrıntılarının görünür olup olmadığını belirtir",
"suggestWidgetHasSelection": "Herhangi bir önerinin odaklanmış olup olmadığını belirtir",
"suggestWidgetMultipleSuggestions": "Seçebileceğiniz birden fazla öneri olup olmadığını belirtir",
"suggestionCanResolve": "Geçerli önerin daha fazla ayrıntı çözümlemeyi destekleyip desteklemediğini belirtir",
"suggestionHasInsertAndReplaceRange": "Geçerli önerinin ekleme ve değiştirme davranışına sahip olup olmadığını belirtir",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "Öneri arabirim öğesindeki daha fazla bilgi simgesi."
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "Dizi sembolleri için ön plan rengi. Bu semboller ana hatta, içerik haritasında ve öneri pencere öğesinde görünür.",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "‘{0}’ dosyası, Satır Ayırıcı (LS) veya Paragraf Ayırıcı (PS) gibi bir veya daha fazla olağan dışı satır sonlandırıcı karakter içeriyor.\r\n\r\nBunların dosyadan kaldırılması önerilir. Bu, `editor.unusualLineTerminators` aracılığıyla yapılandırılabilir.",
"unusualLineTerminators.fix": "Olağan Dışı Satır Sonlandırıcıları Kaldır",
"unusualLineTerminators.fix": "&&Olağan Dışı Satır Sonlandırıcıları Kaldır",
"unusualLineTerminators.ignore": "Yoksay",
"unusualLineTerminators.message": "Olağan dışı satır ayırıcılar algılandı",
"unusualLineTerminators.title": "Olağandışı Satır Ayırıcılar"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "Sembol vurguları için genel bakış cetveli işaretleyici rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"overviewRulerWordHighlightStrongForeground": "Yazma erişimi sembolü vurguları için genel bakış cetveli işaretleyici rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"overviewRulerWordHighlightTextForeground": "Sembol için metin oluşumunun genel bakış cetveli rengi. Altındaki süslemeleri gizlememek için renk opak olmamalıdır.",
"wordHighlight": "Bir değişkeni okuma gibi bir okuma erişimi sırasında bir sembolün arka plan rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"wordHighlight.next.label": "Sonraki Sembol Vurgusuna Git",
"wordHighlight.previous.label": "Önceki Sembol Vurgusuna Git",
"wordHighlight.trigger.label": "Sembol Vurgusu Tetikle",
"wordHighlightBorder": "Bir değişkeni okuma gibi bir okuma erişimi sırasında sembolün kenarlık rengi.",
"wordHighlightStrong": "Bir değişkene yazma gibi bir yazma erişimi sırasında sembolün arka plan rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"wordHighlightStrongBorder": "Bir değişkene yazma gibi bir yazma erişimi sırasında sembolün kenarlık rengi."
"wordHighlightStrongBorder": "Bir değişkene yazma gibi bir yazma erişimi sırasında sembolün kenarlık rengi.",
"wordHighlightText": "Bir sembol için metin oluşumunun arka plan rengi. Altındaki süslemeleri gizlememek için renk opak olmamalıdır.",
"wordHighlightTextBorder": "Sembol için metin oluşumunun kenarlık rengi."
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "Sonraki Sembol Vurgusuna Git",
"wordHighlight.previous.label": "Önceki Sembol Vurgusuna Git",
"wordHighlight.trigger.label": "Sembol Vurgusu Tetikle"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "Sözcük Sil"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "Geliştirici",
"help": "Yardım",
"preferences": "Tercihler",
"test": "Test",
"view": "Görüntüle"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "Gizle",
"resetThisMenu": "Sıfırlama Menüsü"
},
"vs/platform/actions/common/menuService": {
"hide.label": "'{0}' öğesini gizle"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "Eylem Widget'ı",
"customQuickFixWidget.labels": "{0}, Devre Dışı Bırakılma Nedeni: {1}",
"label": "Uygulamak için {0}",
"label-preview": "Uygulamak için {0}, önizlemek için {1}"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "Seçili eylemi kabul et",
"codeActionMenuVisible": "Eylem widget listesinin görünür olup olmadığı",
"hideCodeActionWidget.title": "Eylem widget'ını gizle",
"previewSelected.title": "Seçilen eylemi önizle",
"selectNextCodeAction.title": "Sonraki eylemi seç",
"selectPrevCodeAction.title": "Önceki eylemi seçin"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "Silinen Fark Satırı",
"audioCues.diffLineInserted": "Eklenen Fark Satırı",
"audioCues.diffLineModified": "Fark Satırı Değiştirildi",
"audioCues.lineHasBreakpoint.name": "Satırda Kesme Noktası",
"audioCues.lineHasError.name": "Satırda Hata",
"audioCues.lineHasFoldedArea.name": "Satırda Katlanmış Alan",
"audioCues.lineHasInlineSuggestion.name": "Satırda Satır İçi Öneri",
"audioCues.lineHasWarning.name": "Satırda Uyarı",
"audioCues.noInlayHints": "Satırda Döşeme İpucu Yok",
"audioCues.notebookCellCompleted": "Not Defteri Hücresi Tamamlandı",
"audioCues.notebookCellFailed": "Not Defteri Hücresi Başarısız Oldu",
"audioCues.onDebugBreak.name": "Hata Ayıklayıcı Kesme Noktasında Durduruldu",
"audioCues.taskCompleted": "Görev Tamamlandı",
"audioCues.taskFailed": "Görev Başarısız Oldu",
"audioCues.terminalBell": "Terminal Zili",
"audioCues.terminalCommandFailed": "Terminal Komutu Başarısız Oldu",
"audioCues.terminalQuickFix.name": "Terminal Hızlı Düzeltme"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "'{0}' kaydedilemiyor. İlişkili ilke {1}, zaten {2} ile kaydedilmiş.",
"config.property.duplicate": "'{0}' kaydedilemiyor. Bu özellik zaten kayıtlı.",
"config.property.empty": "Boş bir özellik kaydedilemez",
"config.property.languageDefault": "'{0}' kaydedilemiyor. Bu, dile özgü düzenleyici ayarlarını açıklayan '\\\\[.* \\\\]$' özellik deseniyle eşleşiyor. 'configurationDefaults' katkısını kullanın.",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "İşletim sisteminin Linux olup olmadığını belirtir",
"isMac": "İşletim sisteminin macOS olup olmadığını belirtir",
"isMacNative": "İşletim sisteminin tarayıcı dışı bir platformda macOS olup olmadığını belirtir",
"isMobile": "Platformun bir web tarayıcısı olup olmadığını belirtir",
"isWeb": "Platformun bir web tarayıcısı olup olmadığını belirtir",
"isWindows": "İşletim sisteminin Windows olup olmadığını belirtir"
"isWindows": "İşletim sisteminin Windows olup olmadığını belirtir",
"productQualityType": "VS Code’un Kalite türü"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "İptal",
"moreFile": "...1 ek dosya gösterilmedi",
"moreFiles": "...{0} ek dosya gösterilmedi"
"moreFiles": "...{0} ek dosya gösterilmedi",
"okButton": "&&Tamam",
"yesButton": "&&Evet"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "Dosya adsız düzenleyici olarak açılmak için çok büyük. Lütfen önce dosyayı dosya gezginine yükleyin ve sonra yeniden deneyin."
},
"vs/platform/files/common/files": {
"sizeB": "{0} Bayt",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "`Alt` tuşuna basılırken kaydırma hızı çarpanı.",
"Mouse Wheel Scroll Sensitivity": "Fare tekerleği kaydırma olaylarının 'deltaX' ve 'deltaY' değerleri üzerinde kullanılacak çarpan.",
"automatic keyboard navigation setting": "Liste ve ağaçlarda klavye gezinmesinin otomatik tetiklenmesi için yazmaya başlamanın yeterli olup olmadığını denetler. `false` olarak ayarlanırsa klavye gezinmesi yalnızca bir klavye kısayolu atayabileceğiniz `list.toggleKeyboardNavigation` komutu yürütülürken tetiklenir.",
"defaultFindMatchTypeSettingKey": "Çalışma masasında liste ve ağaç aranırken kullanılan eşleştirme türünü denetler.",
"defaultFindMatchTypeSettingKey.contiguous": "Arama yaparken bitişik eşleştirme kullanın.",
"defaultFindMatchTypeSettingKey.fuzzy": "Arama yaparken benzer öğe eşleştirme kullanın.",
"defaultFindModeSettingKey": "Çalışma masasındaki listeler ve ağaçlar için varsayılan bulma modunu denetler.",
"defaultFindModeSettingKey.filter": "Arama yaparken öğeleri filtreleme.",
"defaultFindModeSettingKey.highlight": "Arama yaparken öğeleri vurgulama. Daha fazla yukarı ve aşağı gezinti, yalnızca vurgulanan öğelerde geçiş sağlar.",
"expand mode": "Klasör adlarına tıklandığında ağaç klasörlerinin nasıl genişletileceğini denetler. Uygulanamıyorsa, bazı ağaçların ve listelerin bu ayarı yoksaymayı seçebileceğine dikkat edin.",
"horizontalScrolling setting": "Liste ve ağaçların workbench'te yatay kaydırmayı destekleyip desteklemeyeceğini denetler. Uyarı: Bu ayarı açmanın, performansa etkisi olur.",
"keyboardNavigationSettingKey": "Workbench'teki liste ve ağaçların klavye gezinti stilini denetler. Basit, vurgu ve filtre olabilir.",
"keyboardNavigationSettingKey.filter": "Filtre klavye gezintisi, klavye girişiyle eşleşmeyen tüm öğeleri filtreler ve gizler.",
"keyboardNavigationSettingKey.highlight": "Vurgu klavye gezintisi, klavye girişiyle eşleşen öğeleri vurgular. Gezinti yukarı ve aşağı yönde sürdürüldüğünde yalnızca vurgulanan öğelerde dolaşılır.",
"keyboardNavigationSettingKey.simple": "Basit klavye gezintisi, klavye girişiyle eşleşen öğelere odaklanır. Eşleşme yalnızca ön eklerde yapılır.",
"keyboardNavigationSettingKeyDeprecated": "Lütfen bunun yerine 'workbench.list.defaultFindMode' ve 'workbench.list.typeNavigationMode' kullanın.",
"list smoothScrolling setting": "Liste ve ağaçlarda düzgün kaydırma olup olmayacağını denetler.",
"list.scrollByPage": "Kaydırma çubuğundaki tıklamaların sayfa sayfa kaydırılıp kaydırılmadığını denetler.",
"multiSelectModifier": "Ağaçlara ve listelere fare ile çoklu seçim yapılabilecek bir öğe eklemek için kullanılacak değiştirici (örneğin gezginde, açık düzenleyicilerde ve SCM görünümünde). 'Yanda Aç' fare hareketleri destekleniyorsa, birden çok öğe seçme değiştiricisi ile çakışmayacak şekilde uyarlanır.",
"multiSelectModifier.alt": "Windows ve Linux'ta `Alt`, macOS'te `Option` ile eşlenir.",
"multiSelectModifier.ctrlCmd": "Windows ve Linux'ta `Control`, macOS'te `Command` ile eşlenir.",
"openModeModifier": "Ağaç ve listelerdeki öğelerin fare kullanılarak (destekleniyorsa) nasıl açılacağını denetler. Uygulanamıyorsa, bazı ağaçların ve listelerin bu ayarı yoksaymayı seçebileceğine dikkat edin.",
"render tree indent guides": "Ağacın girinti kılavuzlarını işleyip işlemeyeceğini denetler.",
"tree indent setting": "Piksel cinsinden ağaç girintilemesini denetler.",
"typeNavigationMode": "Workbench'teki listelerde ve ağaçlarda tür gezintisinin nasıl çalıştığını kontrol eder. 'trigger' olarak ayarlandığında, 'list.triggerTypeNavigation' komutu çalıştırıldığında tür gezintisi başlar.",
"workbenchConfigurationTitle": "Workbench"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "Uyarı"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "'{0}' komutu bir hatayla sonuçlandı ({1})",
"canNotRun": "'{0}' komutu bir hatayla sonuçlandı",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "sık kullanılan",
"morecCommands": "diğer komutlar",
"recentlyUsed": "son kullanılanlar"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "düzenleyici komutları",
"globalCommands": "genel komutlar",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "Özel",
"inputModeEntry": "Girişinizi onaylamak için 'Enter' tuşuna, iptal etmek için 'Escape' tuşuna basın",
"inputModeEntryDescription": "{0} (Onaylamak için 'Enter' tuşuna, iptal etmek için 'Escape' tuşuna basın)",
"ok": "Tamam",
"quickInput.back": "Geri",
"quickInput.backWithKeybinding": "Geri ({0})",
"quickInput.checkAll": "Tüm onay kutularını değiştir",
"quickInput.countSelected": "{0} Seçili",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} Sonuç",
"quickInputBox.ariaLabel": "Sonuçları daraltmak için yazın."
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "Hızlı Giriş"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "'{0}' komutunu yürütmek için tıklayın"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "Daha fazla karşıtlık için etkin öğelerin çevresindeki, bunları diğerlerinden ayırmaya yönelik fazladan bir kenarlık.",
"activeLinkForeground": "Etkin bağlantıların rengi.",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "İçerik haritası öğelerinin arka plan rengi.",
"breadcrumbsFocusForeground": "Odaklanılmış içerik haritası öğelerinin rengi.",
"breadcrumbsSelectedBackground": "İçerik haritası öğe seçicisinin arka plan rengi.",
"breadcrumbsSelectedForegound": "Seçili içerik haritası öğelerinin rengi.",
"breadcrumbsSelectedForeground": "Seçili içerik haritası öğelerinin rengi.",
"buttonBackground": "Düğme arka plan rengi.",
"buttonBorder": "Düğme kenarlığı rengi.",
"buttonForeground": "Düğme ön plan rengi.",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "İkincil düğme arka plan rengi.",
"buttonSecondaryForeground": "İkincil düğme ön plan rengi.",
"buttonSecondaryHoverBackground": "Üzerinde gelindiğinde ikincil düğme arka plan rengi.",
"buttonSeparator": "Düğme ayırıcı rengi.",
"chartsBlue": "Grafik görselleştirmelerinde kullanılan mavi renk.",
"chartsForeground": "Grafiklerde kullanılan ön plan rengi.",
"chartsGreen": "Grafik görselleştirmelerinde kullanılan yeşil renk.",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "Onay kutusu pencere öğesinin arka plan rengi.",
"checkbox.border": "Onay kutusu pencere öğesinin kenarlık rengi.",
"checkbox.foreground": "Onay kutusu pencere öğesinin ön plan rengi.",
"checkbox.select.background": "Onay kutusu pencere öğesinin içinde yer aldığı öğe seçiliyken onay kutusu pencere öğesinin arka plan rengi.",
"checkbox.select.border": "Onay kutusu pencere öğesinin içinde yer aldığı öğe seçiliyken onay kutusu pencere öğesinin kenarlık rengi.",
"contrastBorder": "Daha fazla karşıtlık için öğelerin çevresindeki, bunları diğerlerinden ayırmaya yönelik fazladan kenarlık.",
"descriptionForeground": "Etiket gibi ek bilgi sağlayan açıklama metin için ön plan rengi.",
"diffDiagonalFill": "Fark düzenleyicisinin çapraz dolgusunun rengi. Çapraz dolgu yan yana fark görünümlerinde kullanılır.",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "Satırların kaldırılmış olduğu kenar boşluğu için arka plan rengi.",
"diffEditorRemovedLines": "Kaldırılan satırlar için arka plan rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"diffEditorRemovedOutline": "Kaldırılan metin için ana hat rengi.",
"disabledForeground": "Devre dışı bırakılmış öğeler için genel ön plan. Bu renk, bir bileşen tarafından geçersiz kılınmadıkça kullanılır.",
"dropdownBackground": "Açılır liste arka planı.",
"dropdownBorder": "Açılır liste kenarlığı.",
"dropdownForeground": "Açılır liste ön planı.",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "Seçili metnin yüksek karşıtlık için rengi.",
"editorSelectionHighlight": "Seçimle aynı içeriğe sahip bölgelerin rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"editorSelectionHighlightBorder": "Seçimle aynı içeriğe sahip bölgeler için kenarlık rengi.",
"editorStickyScrollBackground": "Düzenleyici için yapışkan kaydırma arka plan rengi",
"editorStickyScrollHoverBackground": "Düzenleyici için üzerine gelindiğinde yapışkan kaydırma arka plan rengi",
"editorWarning.background": "Düzenleyicide uyarı metninin arka plan rengi. Alttaki süslemeleri gizlememesi için rengin opak olmaması gerekir.",
"editorWarning.foreground": "Düzenleyicideki uyarı dalgalı çizgilerinin ön plan rengi.",
"editorWidgetBackground": "Bul/değiştir gibi düzenleyici pencere öğelerinin arka plan rengi.",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "Listelerde ve ağaçlarda tür filtresi pencere öğesinin arka plan rengi.",
"listFilterWidgetNoMatchesOutline": "Bir eşleşme olmadığında, listelerde ve ağaçlarda tür filtresi pencere öğesinin ana hat rengi.",
"listFilterWidgetOutline": "Listelerde ve ağaçlarda tür filtresi pencere öğesinin ana hat rengi.",
"listFilterWidgetShadow": "Listelerde ve ağaçlardaki tür filtresi pencere öğesinin gölgelendirme rengi.",
"listFocusAndSelectionOutline": "Liste/Ağaç etkin ve seçiliyken odaklanılan öğe için liste/ağaç ana hat rengi. Etkin liste/ağaç klavye odağına sahipken, etkin olmayan sahip değildir.",
"listFocusBackground": "Liste/ağaç etkinken odaklanılan öğe için liste/ağaç arka plan rengi. Etkin bir liste/ağaç klavye odağına sahiptir, etkin olmayan değildir.",
"listFocusForeground": "Liste/ağaç etkinken odaklanılan öğenin liste/ağaç ön plan rengi. Etkin bir liste/ağaç klavye odağına sahiptir, etkin olmayan değildir.",
"listFocusHighlightForeground": "Liste/Ağaç içinde arama yaparken odaklanılan etkin öğeler için eşleşme vurgularının Liste/Ağaç ön plan rengi.",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "Fareyi eylemler üzerinde tutarken araç çubuğu arka planı",
"toolbarHoverBackground": "Fareyi kullanarak eylemler üzerinde hareket ederken araç çubuğu arka planı",
"toolbarHoverOutline": "Fareyi kullanarak eylemler üzerinde hareket ederken araç çubuğu ana hattı",
"treeInactiveIndentGuidesStroke": "Etkin olmayan girinti kılavuzları için ağaç fırça darbesi rengi.",
"treeIndentGuidesStroke": "Girinti kılavuzları için ağaç fırça darbesi rengi.",
"warningBorder": "Düzenleyicideki uyarı kutularının kenarlık rengi.",
"widgetBorder": "Düzenleyici içinde bul/değiştir gibi widget'ların kenarlık rengi.",
"widgetShadow": "Düzenleyici içinde bulma/değiştirme gibi pencere öğelerinin gölge rengi."
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "Pencere öğelerindeki kapatma eylemi için simge."
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "İptal",
"cannotResourceRedoDueToInProgressUndoRedo": "Zaten çalışmakta olan bir geri alma veya yineleme işlemi olduğundan '{0}' yinelenemedi.",
"cannotResourceUndoDueToInProgressUndoRedo": "Zaten çalışmakta olan bir geri alma veya yineleme işlemi olduğundan '{0}' geri alınamadı.",
"cannotWorkspaceRedo": "'{0}' tüm dosyalarda yinelenemiyor. {1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "{1} üzerinde zaten çalışan bir geri alma veya yineleme işlemi olduğundan '{0}' tüm dosyalarda geri alınamadı",
"confirmDifferentSource": "'{0}' öğesini geri almak istiyor musunuz?",
"confirmDifferentSource.no": "Hayır",
"confirmDifferentSource.yes": "Evet",
"confirmDifferentSource.yes": "&&Evet",
"confirmWorkspace": "'{0}' işlemini tüm dosyalarda geri almak istiyor musunuz?",
"externalRemoval": "Şu dosyalar diskte kapatıldı ve değiştirildi: {0}.",
"noParallelUniverses": "Şu dosyalar uyumsuz bir şekilde değiştirildi: {0}.",
"nok": "Bu Dosyayı Geri Al",
"ok": "{0} Dosyada Geri Al"
"nok": "Bu &&Dosyayı Geri Al",
"ok": "{0} Dosyada &&Geri Al"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Kod Çalışma Alanı"

408
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/zh-hans.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "更多操作..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "关闭对话框",
"dialogErrorMessage": "错误",
"dialogInfoMessage": "信息",
"dialogPendingMessage": "正在进行",
"dialogWarningMessage": "警告",
"ok": "确定"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "更多操作..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "输入"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "区分大小写",
"regexDescription": "使用正则表达式",
"wordsDescription": "全字匹配"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "输入",
"label.preserveCaseToggle": "保留大小写"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "未绑定"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "选择框"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "更多操作..."
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "清除",
"disable filter on type": "禁用输入时筛选",
"empty": "未找到元素",
"enable filter on type": "启用输入时筛选",
"found": "已匹配 {0} 个元素(共 {1} 个)"
"close": "关闭",
"filter": "筛选器",
"fuzzySearch": "模糊匹配",
"not found": "未找到元素。",
"type to filter": "要筛选的类型",
"type to search": "要搜索的类型"
},
"vs/base/common/actions": {
"submenu.empty": "(空)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "自定义",
"inputModeEntry": "按 \"Enter\" 以确认或按 \"Esc\" 以取消",
"inputModeEntryDescription": "{0} (按 \"Enter\" 以确认或按 \"Esc\" 以取消)",
"ok": "确定",
"quickInput.back": "上一步",
"quickInput.backWithKeybinding": "后退 ({0})",
"quickInput.countSelected": "已选 {0} 项",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} 个结果",
"quickInputBox.ariaLabel": "在此输入可缩小结果范围。"
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "快速输入"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "现在无法访问编辑器。按 {0} 获取选项。",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "撤消"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "光标数量被限制为 {0}。"
"cursors.maximum": "已将光标数限制为 {0}。请考虑使用 [查找和替换](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace)进行较大的更改或增加编辑器多光标限制设置。",
"goToSetting": "增加多光标限制"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " 使用 Shift + F7 导航更改",
"diff.tooLarge": "文件过大，无法比较。",
"diffInsertIcon": "差异编辑器中插入项的线条修饰。",
"diffRemoveIcon": "差异编辑器中删除项的线条修饰。"
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "控制是否在编辑器中显示 CodeLens。",
"detectIndentation": "控制是否在打开文件时，基于文件内容自动检测 `#editor.tabSize#` 和 `#editor.insertSpaces#`。",
"detectIndentation": "控制在基于文件内容打开文件时是否自动检测 {0} 和 {1}。",
"diffAlgorithm.experimental": "使用实验性差异算法。",
"diffAlgorithm.smart": "使用默认的差异算法。",
"editor.experimental.asyncTokenization": "控制是否应在 Web 辅助进程上异步进行标记化。",
"editorConfigurationTitle": "编辑器",
"ignoreTrimWhitespace": "启用后，差异编辑器将忽略前导空格或尾随空格中的更改。",
"insertSpaces": "按 `Tab` 键时插入空格。该设置在 `#editor.detectIndentation#` 启用时根据文件内容可能会被覆盖。",
"indentSize": "用于缩进或 `\"tabSize\"` 的空格数，可使用 `#editor.tabSize#` 中的值。当 `#editor.detectIndentation#` 处于打开状态时，将根据文件内容替代此设置。",
"insertSpaces": "按 `Tab` 时插入空格。当 {0} 打开时，将根据文件内容替代此设置。",
"largeFileOptimizations": "对大型文件进行特殊处理，禁用某些内存密集型功能。",
"maxComputationTime": "超时(以毫秒为单位)，之后将取消差异计算。使用0表示没有超时。",
"maxFileSize": "要为其计算差异的最大文件大小(MB)。使用 0 表示无限制。",
"maxTokenizationLineLength": "由于性能原因，超过这个长度的行将不会被标记",
"renderIndicators": "控制差异编辑器是否为添加/删除的更改显示 +/- 指示符号。",
"renderMarginRevertIcon": "启用后，差异编辑器会在其字形边距中显示箭头以还原更改。",
"schema.brackets": "定义增加和减少缩进的括号。",
"schema.closeBracket": "右方括号字符或字符串序列。",
"schema.colorizedBracketPairs": "如果启用方括号对着色，则按照其嵌套级别定义已着色的方括号对。",
@ -139,15 +160,15 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.false": "对所有颜色主题禁用语义突出显示。",
"semanticHighlighting.true": "对所有颜色主题启用语义突出显示。",
"sideBySide": "控制差异编辑器的显示方式是并排还是内联。",
"stablePeek": "在速览编辑器中，即使双击其中的内容或者按 `Esc` 键，也保持其打开状态。",
"tabSize": "一个制表符等于的空格数。在 `#editor.detectIndentation#` 启用时，根据文件内容，该设置可能会被覆盖。",
"stablePeek": "保持速览编辑器处于打开状态，即使双击其中的内容或者点击 `Escape` 键也是如此。",
"tabSize": "一个制表符等于的空格数。当 {0} 打开时，将根据文件内容替代此设置。",
"trimAutoWhitespace": "删除自动插入的尾随空白符号。",
"wordBasedSuggestions": "控制是否根据文档中的文字计算自动完成列表。",
"wordBasedSuggestions": "控制是否根据文档中的字词计算自动补全列表。",
"wordBasedSuggestionsMode": "控制通过哪些文档计算基于字词的补全。",
"wordBasedSuggestionsMode.allDocuments": "建议所有打开的文档中的字词。",
"wordBasedSuggestionsMode.currentDocument": "仅建议活动文档中的字词。",
"wordBasedSuggestionsMode.matchingDocuments": "建议使用同一语言的所有打开的文档中的字词。",
"wordWrap.inherit": "将根据 `#editor.wordWrap#` 设置换行。",
"wordWrap.inherit": "行将根据 {0} 设置进行换行。",
"wordWrap.off": "永不换行。",
"wordWrap.on": "将在视区宽度处换行。"
},
@ -156,10 +177,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"acceptSuggestionOnEnter": "控制除了 `Tab` 键以外， `Enter` 键是否同样可以接受建议。这能减少“插入新行”和“接受建议”命令之间的歧义。",
"acceptSuggestionOnEnterSmart": "仅当建议包含文本改动时才可使用 `Enter` 键进行接受。",
"accessibilityPageSize": "控制编辑器中可由屏幕阅读器一次读出的行数。我们检测到屏幕阅读器时，会自动将默认值设置为 500。警告: 如果行数大于默认值，可能会影响性能。",
"accessibilitySupport": "控制编辑器是否应在对屏幕阅读器进行了优化的模式下运行。设置为“开”将禁用自动换行。",
"accessibilitySupport.auto": "编辑器将使用平台 API 以检测是否附加了屏幕阅读器。",
"accessibilitySupport.off": "编辑器将不再对屏幕阅读器的使用进行优化。",
"accessibilitySupport.on": "编辑器将针对与屏幕阅读器搭配使用进行永久优化。将禁用自动换行。",
"accessibilitySupport": "控制 UI 是否应在已针对屏幕阅读器进行优化的模式下运行。",
"accessibilitySupport.auto": "连接屏幕阅读器后使用平台 API 进行检测",
"accessibilitySupport.off": "假定未连接屏幕阅读器",
"accessibilitySupport.on": "针对屏幕阅读器的使用进行优化",
"alternativeDeclarationCommand": "当\"转到声明\"的结果为当前位置时将要执行的替代命令的 ID。",
"alternativeDefinitionCommand": "当\"转到定义\"的结果为当前位置时将要执行的替代命令的 ID。",
"alternativeImplementationCommand": "当\"转到实现\"的结果为当前位置时将要执行的替代命令的 ID。",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "控制编辑器是否在左引号后自动插入右引号。",
"autoIndent": "控制编辑器是否应在用户键入、粘贴、移动或缩进行时自动调整缩进。",
"autoSurround": "控制在键入引号或方括号时，编辑器是否应自动将所选内容括起来。",
"bracketPairColorization.enabled": "控制是否已启用括号对着色。使用 `#workbench.colorCustomizations#` 替代括号高亮颜色。",
"bracketPairColorization.enabled": "控制是否启用括号对着色。请使用 {0} 重写括号突出显示颜色。",
"bracketPairColorization.independentColorPoolPerBracketType": "控制每个方括号类型是否具有自己的独立颜色池。",
"codeActions": "在编辑器中启用代码操作小灯泡提示。",
"codeLens": "控制是否在编辑器中显示 CodeLens。",
"codeLensFontFamily": "控制 CodeLens 的字体系列。",
"codeLensFontSize": "控制 CodeLens 的字号(以像素为单位)。设置为 `0` 时，将使用 90% 的 `#editor.fontSize#`。",
"codeLensFontSize": "控制 CodeLens 的字号(以像素为单位)。设置为 0 时，将使用 90% 的 `#editor.fontSize#`。",
"colorDecorators": "控制编辑器是否显示内联颜色修饰器和颜色选取器。",
"colorDecoratorsLimit": "控制可一次性在编辑器中呈现的最大颜色修饰器数。",
"columnSelection": "启用使用鼠标和键进行列选择。",
"comments.ignoreEmptyLines": "控制在对行注释执行切换、添加或删除操作时，是否应忽略空行。",
"comments.insertSpace": "控制在注释时是否插入空格字符。",
"copyWithSyntaxHighlighting": "控制在复制时是否同时复制语法高亮。",
"cursorBlinking": "控制光标的动画样式。",
"cursorSmoothCaretAnimation": "控制是否启用平滑插入动画。",
"cursorSmoothCaretAnimation.explicit": "仅当用户使用显式手势移动光标时，才启用平滑脱字号动画。",
"cursorSmoothCaretAnimation.off": "已禁用平滑脱字号动画。",
"cursorSmoothCaretAnimation.on": "始终启用平滑脱字号动画。",
"cursorStyle": "控制光标样式。",
"cursorSurroundingLines": "控制光标周围可见的前置行和尾随行的最小数目。在其他一些编辑器中称为 \"scrollOff\" 或 \"scrollOffset\"。",
"cursorSurroundingLines": "控制光标周围可见的前置行(最小值为 0)和尾随行(最小值为 1)的最小数目。在其他一些编辑器中称为 “scrollOff” 或 “scrollOffset”。",
"cursorSurroundingLinesStyle": "控制何时应强制执行\"光标环绕行\"。",
"cursorSurroundingLinesStyle.all": "始终强制执行 \"cursorSurroundingLines\"",
"cursorSurroundingLinesStyle.default": "仅当通过键盘或 API 触发时，才会强制执行\"光标环绕行\"。",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "控制\"转到定义\"鼠标手势是否始终打开预览小部件。",
"deprecated": "此设置已弃用，请改用单独的设置，如\"editor.suggest.showKeywords\"或\"editor.suggest.showSnippets\"。",
"dragAndDrop": "控制在编辑器中是否允许通过拖放来移动选中内容。",
"dropIntoEditor.enabled": "控制是否可以通过按住 `Shift` (而不是在编辑器中打开文件)将文件拖放到编辑器中。",
"editor.autoClosingBrackets.beforeWhitespace": "仅当光标位于空白字符左侧时，才自动闭合括号。",
"editor.autoClosingBrackets.languageDefined": "使用语言配置确定何时自动闭合括号。",
"editor.autoClosingDelete.auto": "仅在自动插入时才删除相邻的右引号或右括号。",
@ -219,9 +245,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.find.seedSearchStringFromSelection.never": "切勿为编辑器选择中的搜索字符串设定种子。",
"editor.find.seedSearchStringFromSelection.selection": "仅为编辑器选择中的搜索字符串设定种子。",
"editor.gotoLocation.multiple.deprecated": "此设置已弃用，请改用单独的设置，如\"editor.editor.gotoLocation.multipleDefinitions\"或\"editor.editor.gotoLocation.multipleImplementations\"。",
"editor.gotoLocation.multiple.goto": "转到主结果，并对其他人启用防偷窥导航",
"editor.gotoLocation.multiple.gotoAndPeek": "转到主结果并显示预览视图",
"editor.gotoLocation.multiple.peek": "显示结果的预览视图 (默认值)",
"editor.gotoLocation.multiple.goto": "转到主结果，并对其他结果启用无速览导航",
"editor.gotoLocation.multiple.gotoAndPeek": "转到主结果并显示速览视图",
"editor.gotoLocation.multiple.peek": "显示结果的速览视图(默认)",
"editor.guides.bracketPairs": "控制是否启用括号对指南。",
"editor.guides.bracketPairs.active": "仅为活动括号对启用括号对参考线。",
"editor.guides.bracketPairs.false": "禁用括号对参考线。",
@ -232,13 +258,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "启用水平参考线作为垂直括号对参考线的添加项。",
"editor.guides.highlightActiveBracketPair": "控制编辑器是否应突出显示活动的括号对。",
"editor.guides.highlightActiveIndentation": "控制是否突出显示编辑器中活动的缩进参考线。",
"editor.guides.highlightActiveIndentation.always": "突出显示活动缩进参考线，即使突出显示了括号参考线。",
"editor.guides.highlightActiveIndentation.false": "不要突出显示活动缩进参考线。",
"editor.guides.highlightActiveIndentation.true": "突出显示活动缩进参考线。",
"editor.guides.indentation": "控制编辑器是否显示缩进参考线。",
"editor.inlayHints.off": "已禁用内嵌提示",
"editor.inlayHints.offUnlessPressed": "默认情况下隐藏内嵌提示，并在按住 {0} 时显示",
"editor.inlayHints.on": "已启用内嵌提示",
"editor.inlayHints.onUnlessPressed": "默认情况下显示内嵌提示，并在按住 {0} 时隐藏",
"editor.stickyScroll": "在编辑器顶部的滚动过程中显示嵌套的当前作用域。",
"editor.stickyScroll.": "定义要显示的最大粘滞行数。",
"editor.suggest.matchOnWordStartOnly": "启用后，IntelliSense 筛选要求第一个字符在单词开头匹配，例如 “Console” 或 “WebContext” 上的 “c”，但 “description” 上的 _not_。禁用后，IntelliSense 将显示更多结果，但仍按匹配质量对其进行排序。",
"editor.suggest.showClasss": "启用后，IntelliSense 将显示“类”建议。",
"editor.suggest.showColors": "启用后，IntelliSense 将显示“颜色”建议。",
"editor.suggest.showConstants": "启用后，IntelliSense 将显示“常量”建议。",
"editor.suggest.showConstructors": "启用后，IntelliSense 将显示“构造函数”建议。",
"editor.suggest.showCustomcolors": "启用后，IntelliSense 将显示“自定义颜色”建议。",
"editor.suggest.showDeprecated": "启用后，IntelliSense 将显示“已启用”建议。",
"editor.suggest.showDeprecated": "启用后，IntelliSense 将显示`已弃用`建议。",
"editor.suggest.showEnumMembers": "启用后，IntelliSense 将显示 \"enumMember\" 建议。",
"editor.suggest.showEnums": "启用后，IntelliSense 将显示“枚举”建议。",
"editor.suggest.showEvents": "启用后，IntelliSense 将显示“事件”建议。",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "启用后，IntelliSense 将显示“变量”建议。",
"editorViewAccessibleLabel": "编辑器内容",
"emptySelectionClipboard": "控制在没有选择内容时进行复制是否复制当前行。",
"experimentalWhitespaceRendering": "控制是否使用新的实验性方法呈现空格。",
"experimentalWhitespaceRendering.font": "使用包含字体字符的新呈现方法。",
"experimentalWhitespaceRendering.off": "使用稳定呈现方法。",
"experimentalWhitespaceRendering.svg": "将新的呈现方法与 svg 配合使用。",
"fastScrollSensitivity": "按下\"Alt\"时滚动速度倍增。",
"find.addExtraSpaceOnTop": "控制 \"查找小部件\" 是否应在编辑器顶部添加额外的行。如果为 true, 则可以在 \"查找小工具\" 可见时滚动到第一行之外。",
"find.autoFindInSelection": "控制自动打开“在选定内容中查找”的条件。",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "启用/禁用字体连字(\"calt\" 和 \"liga\" 字体特性)。将此更改为字符串，可对 \"font-feature-settings\" CSS 属性进行精细控制。",
"fontLigaturesGeneral": "配置字体连字或字体特性。可以是用于启用/禁用连字的布尔值，或用于设置 CSS \"font-feature-settings\" 属性值的字符串。",
"fontSize": "控制字体大小(像素)。",
"fontVariationSettings": "显式“font-variation-settings”CSS 属性。如果只需将 font-weight 转换为 font-variation-settings，则可以改为传递布尔值。",
"fontVariations": "启用/禁用从 font-weight 到 font-variation-settings 的转换。将此项更改为字符串，以便对“font-variation-settings”CSS 属性进行细化控制。",
"fontVariationsGeneral": "配置字体变体。可以是用于启用/禁用从 font-weight 到 font-variation-settings 的转换的布尔值，也可以是 CSS“font-variation-settings”属性值的字符串。",
"fontWeight": "控制字体粗细。接受关键字“正常”和“加粗”，或者接受介于 1 至 1000 之间的数字。",
"fontWeightErrorMessage": "仅允许使用关键字“正常”和“加粗”，或使用介于 1 至 1000 之间的数字。",
"formatOnPaste": "控制编辑器是否自动格式化粘贴的内容。格式化程序必须可用，并且能针对文档中的某一范围进行格式化。",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "控制是否显示悬停提示。",
"hover.sticky": "控制当鼠标移动到悬停提示上时，其是否保持可见。",
"inlayHints.enable": "在编辑器中启用内联提示。",
"inlayHints.fontFamily": "在编辑器中控制内嵌提示的字体系列。设置为空时，使用 `#editor.fontFamily#`。",
"inlayHints.fontSize": "控制编辑器中内嵌提示的字号。当配置的值小于 `5` 或大于编辑器字号时，默认使用 90% 的 `#editor.fontSize#`。",
"inlayHints.fontFamily": "控制编辑器中嵌入提示的字体系列。设置为空时，将使用 {0}。",
"inlayHints.fontSize": "控制编辑器中嵌入提示的字号。默认情况下，当配置的值小于 {1} 或大于编辑器字号时，将使用 {0}。",
"inlayHints.padding": "在编辑器中启用叠加提示周围的填充。",
"inline": "快速建议显示为虚影文本",
"inlineSuggest.enabled": "控制是否在编辑器中自动显示内联建议。",
"inlineSuggest.showToolbar": "控制何时显示内联建议工具栏。",
"inlineSuggest.showToolbar.always": "每当显示内联建议时，显示内联建议工具栏。",
"inlineSuggest.showToolbar.onHover": "将鼠标悬停在内联建议上时显示内联建议工具栏。",
"letterSpacing": "控制字母间距(像素)。",
"lineHeight": "控制行高。\r\n - 使用 0 根据字号自动计算行高。\r\n - 介于 0 和 8 之间的值将用作字号的乘数。\r\n - 大于或等于 8 的值将用作有效值。",
"lineNumbers": "控制行号的显示。",
@ -305,9 +352,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"lineNumbers.off": "不显示行号。",
"lineNumbers.on": "将行号显示为绝对行数。",
"lineNumbers.relative": "将行号显示为与光标相隔的行数。",
"linkedEditing": "控制编辑器是否已启用链接编辑。相关符号(如 HTML 标记)在编辑时进行更新，具体由语言而定。",
"linkedEditing": "控制编辑器是否已启用链接编辑。相关符号(如 HTML 标记)将在编辑时进行更新，具体取决于语言。",
"links": "控制是否在编辑器中检测链接并使其可被点击。",
"matchBrackets": "突出显示匹配的括号。",
"minimap.autohide": "控制是否自动隐藏缩略图。",
"minimap.enabled": "控制是否显示缩略图。",
"minimap.maxColumn": "限制缩略图的宽度，控制其最多显示的列数。",
"minimap.renderCharacters": "渲染每行的实际字符，而不是色块。",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "迷你地图的大小与编辑器内容相同(并且可能滚动)。",
"mouseWheelScrollSensitivity": "对鼠标滚轮滚动事件的 `deltaX` 和 `deltaY` 乘上的系数。",
"mouseWheelZoom": "按住 `Ctrl` 键并滚动鼠标滚轮时对编辑器字体大小进行缩放。",
"multiCursorLimit": "控制一次可以在活动编辑器中显示的最大游标数。",
"multiCursorMergeOverlapping": "当多个光标重叠时进行合并。",
"multiCursorModifier": "在通过鼠标添加多个光标时使用的修改键。“转到定义”和“打开链接”功能所需的鼠标动作将会相应调整，不与多光标修改键冲突。[阅读详细信息](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier)。",
"multiCursorModifier": "用于使用鼠标添加多个游标的修饰符。“转到定义”和“打开链接”鼠标手势将进行调整，使其不与 [多光标修饰符](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier)冲突。",
"multiCursorModifier.alt": "映射为 `Alt` (Windows 和 Linux) 或 `Option` (macOS)。",
"multiCursorModifier.ctrlCmd": "映射为 `Ctrl` (Windows 和 Linux) 或 `Command` (macOS)。",
"multiCursorPaste": "控制粘贴时粘贴文本的行计数与光标计数相匹配。",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "控制是将焦点放在内联编辑器上还是放在预览小部件中的树上。",
"peekWidgetDefaultFocus.editor": "打开预览时将焦点放在编辑器上",
"peekWidgetDefaultFocus.tree": "打开速览时聚焦树",
"quickSuggestions": "控制是否在键入时自动显示建议。",
"quickSuggestions": "控制键入时是否应自动显示建议。这可以用于在注释、字符串和其他代码中键入时进行控制。可配置快速建议以显示为虚影文本或建议小组件。另请注意控制建议是否由特殊字符触发的“{0}”设置。",
"quickSuggestions.comments": "在注释内启用快速建议。",
"quickSuggestions.other": "在字符串和注释外启用快速建议。",
"quickSuggestions.strings": "在字符串内启用快速建议。",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "控制何时显示行号槽上的折叠控件。",
"showFoldingControls.always": "始终显示折叠控件。",
"showFoldingControls.mouseover": "仅在鼠标位于装订线上方时显示折叠控件。",
"showFoldingControls.never": "切勿显示折叠控件并减小装订线大小。",
"showUnused": "控制是否淡化未使用的代码。",
"smoothScrolling": "控制编辑器是否使用动画滚动。",
"snippetSuggestions": "控制代码片段是否与其他建议一起显示及其排列的位置。",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "在使用空格进行缩进时模拟制表符的选择行为。所选内容将始终使用制表符停止位。",
"suggest.filterGraceful": "控制对建议的筛选和排序是否考虑小的拼写错误。",
"suggest.insertMode": "控制接受补全时是否覆盖单词。请注意，这取决于扩展选择使用此功能。",
"suggest.insertMode.always": "自动触发 IntelliSense 时始终选择建议。",
"suggest.insertMode.insert": "插入建议而不覆盖光标右侧的文本。",
"suggest.insertMode.never": "自动触发 IntelliSense 时，切勿选择建议。",
"suggest.insertMode.replace": "插入建议并覆盖光标右侧的文本。",
"suggest.insertMode.whenQuickSuggestion": "仅在键入时触发 IntelliSense 时才选择建议。",
"suggest.insertMode.whenTriggerCharacter": "仅当从触发器字符触发 IntelliSense 时，才选择建议。",
"suggest.localityBonus": "控制排序时是否首选光标附近的字词。",
"suggest.maxVisibleSuggestions.dep": "此设置已弃用。现在可以调整建议小组件的大小。",
"suggest.preview": "控制是否在编辑器中预览建议结果。",
"suggest.selectionMode": "控制在显示小组件时是否选择建议。请注意，这仅适用于(“#editor.quickSuggestions#”和“#editor.suggestOnTriggerCharacters#”)自动触发的建议，并且始终在显式调用时选择建议，例如通过“Ctrl+Space”。",
"suggest.shareSuggestSelections": "控制是否在多个工作区和窗口间共享记忆的建议选项(需要 `#editor.suggestSelection#`)。",
"suggest.showIcons": "控制是否在建议中显示或隐藏图标。",
"suggest.showInlineDetails": "控制建议详细信息是随标签一起显示还是仅显示在详细信息小组件中",
"suggest.showInlineDetails": "控制建议详细信息是随标签内联显示还是仅显示在详细信息小组件中。",
"suggest.showStatusBar": "控制建议小部件底部的状态栏的可见性。",
"suggest.snippetsPreventQuickSuggestions": "控制活动代码段是否阻止快速建议。",
"suggestFontSize": "建议小部件的字号。如果设置为 `0`，则使用 `#editor.fontSize#` 的值。",
"suggestLineHeight": "建议小部件的行高。如果设置为 `0`，则使用 `#editor.lineHeight#` 的值。最小值为 8。",
"suggestFontSize": "建议小组件的字号。设置为 {0} 时，将使用 {1} 的值。",
"suggestLineHeight": "建议小组件的行高。设置为 {0} 时，将使用 {1} 的值。最小值为 8。",
"suggestOnTriggerCharacters": "控制在键入触发字符后是否自动显示建议。",
"suggestSelection": "控制在建议列表中如何预先选择建议。",
"suggestSelection.first": "始终选择第一个建议。",
@ -410,12 +465,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "禁用 Tab 补全。",
"tabCompletion.on": "在按下 Tab 键时进行 Tab 补全，将插入最佳匹配建议。",
"tabCompletion.onlySnippets": "在前缀匹配时进行 Tab 补全。在 \"quickSuggestions\" 未启用时体验最好。",
"tabFocusMode": "控制编辑器是接收选项卡还是将其延迟到工作台进行导航。",
"unfoldOnClickAfterEndOfLine": "控制单击已折叠的行后面的空内容是否会展开该行。",
"unicodeHighlight.allowedCharacters": "定义未突出显示的允许字符。",
"unicodeHighlight.allowedLocales": "未突出显示在允许区域设置中常见的 Unicode 字符。",
"unicodeHighlight.ambiguousCharacters": "控制是否突出显示可能与基本 ASCII 字符混淆的字符，但当前用户区域设置中常见的字符除外。",
"unicodeHighlight.includeComments": "控制注释中的字符是否也应进行 Unicode 突出显示。",
"unicodeHighlight.includeStrings": "控制字符串中的字符是否也应进行 unicode 突出显示。",
"unicodeHighlight.includeStrings": "控制字符串中的字符是否也应进行 Unicode 突出显示。",
"unicodeHighlight.invisibleCharacters": "控制是否突出显示仅保留空格或完全没有宽度的字符。",
"unicodeHighlight.nonBasicASCII": "控制是否突出显示所有非基本 ASCII 字符。只有介于 U+0020 到 U+007E 之间的字符、制表符、换行符和回车符才被视为基本 ASCII。",
"unusualLineTerminators": "删除可能导致问题的异常行终止符。",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "忽略异常的行终止符。",
"unusualLineTerminators.prompt": "提示删除异常的行终止符。",
"useTabStops": "根据制表位插入和删除空格。",
"wordBreak": "控制中文/日语/韩语(CJK)文本使用的断字规则。",
"wordBreak.keepAll": "中文/日语/韩语(CJK)文本不应使用断字功能。非 CJK 文本行为与普通文本行为相同。",
"wordBreak.normal": "使用默认换行规则。",
"wordSeparators": "执行单词相关的导航或操作时作为单词分隔符的字符。",
"wordWrap": "控制折行的方式。",
"wordWrap.bounded": "在视区宽度和 `#editor.wordWrapColumn#` 中的较小值处折行。",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "折行的缩进量比其父级多 1。",
"wrappingIndent.none": "没有缩进。折行从第 1 列开始。",
"wrappingIndent.same": "折行的缩进量与其父级相同。",
"wrappingStrategy": "控制计算包裹点的算法。",
"wrappingStrategy": "控制计算包装点的算法。请注意，在辅助功能模式下，高级版将用于提供最佳体验。",
"wrappingStrategy.advanced": "将包装点计算委托给浏览器。这是一个缓慢算法，可能会导致大型文件被冻结，但它在所有情况下都正常工作。",
"wrappingStrategy.simple": "假定所有字符的宽度相同。这是一种快速算法，适用于等宽字体和某些字形宽度相等的文字(如拉丁字符)。"
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "非活动括号对指南的背景色(6)。需要启用括号对指南。",
"editorCodeLensForeground": "编辑器 CodeLens 的前景色",
"editorCursorBackground": "编辑器光标的背景色。可以自定义块型光标覆盖字符的颜色。",
"editorDimmedLineNumber": "将 editor.renderFinalNewline 设置为灰色时最终编辑器行的颜色。",
"editorGhostTextBackground": "编辑器中虚影文本的背景色。",
"editorGhostTextBorder": "编辑器中虚影文本的边框颜色。",
"editorGhostTextForeground": "编辑器中虚影文本的前景色。",
"editorGutter": "编辑器导航线的背景色。导航线包括边缘符号和行号。",
"editorIndentGuides": "编辑器缩进参考线的颜色。",
"editorLineNumbers": "编辑器行号的颜色。",
"editorOverviewRulerBackground": "编辑器概述标尺的背景色。仅当缩略图已启用且置于编辑器右侧时才使用。",
"editorOverviewRulerBackground": "编辑器概述标尺的背景色。",
"editorOverviewRulerBorder": "概览标尺边框的颜色。",
"editorRuler": "编辑器标尺的颜色。",
"editorUnicodeHighlight.background": "用于突出显示 Unicode 字符的背景颜色。",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "在当前编辑器中按 Tab 会将焦点移动到下一个可聚焦的元素。当前无法通过按键绑定触发命令 {0}。",
"toggleHighContrast": "切换高对比度主题"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} 字符",
"showMore": "显示更多({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "定位点设置为 {0}:{1}",
"cancelSelectionAnchor": "取消选择定位点",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "复制为",
"miCopy": "复制(&&C)",
"miCut": "剪切(&&T)",
"miPaste": "粘贴(&&P)"
"miPaste": "粘贴(&&P)",
"share": "共享"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "应用代码操作时发生未知错误"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "应用代码操作时发生未知错误",
"args.schema.apply": "控制何时应用返回的操作。",
"args.schema.apply.first": "始终应用第一个返回的代码操作。",
"args.schema.apply.ifSingle": "如果仅返回的第一个代码操作，则应用该操作。",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "整理 import 语句",
"quickfix.trigger.label": "快速修复...",
"refactor.label": "重构...",
"refactor.preview.label": "使用预览重构...",
"source.label": "源代码操作..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "启用/禁用在代码操作菜单中显示组标头。"
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "重写...",
"codeAction.widget.id.extract": "提取...",
"codeAction.widget.id.inline": "内联...",
"codeAction.widget.id.more": "更多操作...",
"codeAction.widget.id.move": "移动...",
"codeAction.widget.id.quickfix": "快速修复...",
"codeAction.widget.id.source": "源代码操作...",
"codeAction.widget.id.surround": "环绕方式..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "隐藏已禁用项",
"showMoreActions": "显示已禁用项"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "显示代码操作",
"codeActionWithKb": "显示代码操作({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "切换行注释(&&T)"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "显示编辑器上下文菜单"
"action.showContextMenu.label": "显示编辑器上下文菜单",
"context.minimap.minimap": "缩略图",
"context.minimap.renderCharacters": "呈现字符",
"context.minimap.size": "垂直大小",
"context.minimap.size.fill": "填充",
"context.minimap.size.fit": "适应",
"context.minimap.size.proportional": "成比例",
"context.minimap.slider": "滑块",
"context.minimap.slider.always": "始终",
"context.minimap.slider.mouseover": "鼠标悬停"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "启用/禁用粘贴时从扩展运行编辑。"
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "正在运行粘贴处理程序..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "光标重做",
"cursor.undo": "光标撤消"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "正在运行放置处理程序..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "编辑器是否运行可取消的操作，例如“预览引用”"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "重写“数学案例”标记。\r\n将不会保留该标记供将来使用。\r\n0: 不执行任何操作\r\n1: True\r\n2: False",
"actions.find.preserveCaseOverride": "重写“保留服务案例”标记。\r\n将不会保留该标记供将来使用。\r\n0: 不执行任何操作\r\n1: True\r\n2: False",
"actions.find.wholeWordOverride": "重写“匹配整个字词”标记。\r\n将不会保留该标记供将来使用。\r\n0: 不执行任何操作\r\n1: True\r\n2: False",
"findMatchAction.goToMatch": "转到“匹配”...",
"findMatchAction.inputPlaceHolder": "键入数字以转到特定匹配项(介于 1 和 {0} 之间)",
"findMatchAction.inputValidationMessage": "请键入介于 1 和 {0} 之间的数字",
"findNextMatchAction": "查找下一个",
"findPreviousMatchAction": "查找上一个",
"miFind": "查找(&&F)",
@ -688,7 +794,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"findSelectionIcon": "编辑器查找小组件中的“在选定内容中查找”图标。",
"label.closeButton": "关闭",
"label.find": "查找",
"label.matchesLocation": "{1} 中的 {0}",
"label.matchesLocation": "第 {0} 项，共 {1} 项",
"label.nextMatchButton": "下一个匹配项",
"label.noResults": "无结果",
"label.previousMatchButton": "上一个匹配项",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "仅高亮了前 {0} 个结果，但所有查找操作均针对全文。"
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "编辑器装订线中折叠控件的颜色。",
"createManualFoldRange.label": "根据所选内容创建折叠范围",
"foldAction.label": "折叠",
"foldAllAction.label": "全部折叠",
"foldAllBlockComments.label": "折叠所有块注释",
"foldAllExcept.label": "折叠除所选区域之外的所有区域",
"foldAllMarkerRegions.label": "折叠所有区域",
"foldBackgroundBackground": "折叠范围后面的背景颜色。颜色必须设为透明，以免隐藏底层装饰。",
"foldLevelAction.label": "折叠级别 {0}",
"foldRecursivelyAction.label": "以递归方式折叠",
"gotoNextFold.label": "转到下一个折叠范围",
"gotoParentFold.label": "跳转到父级折叠",
"gotoPreviousFold.label": "转到上一个折叠范围",
"maximum fold ranges": "可折叠区域的数量限制为最多 {0} 个。增加配置选项[“最大折叠区域数”](command:workbench.action.openSettings?[\"editor.foldingMaximumRegions\"])以启用更多功能。",
"removeManualFoldingRanges.label": "删除手动折叠范围",
"toggleFoldAction.label": "切换折叠",
"unFoldRecursivelyAction.label": "以递归方式展开",
"unfoldAction.label": "展开",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "展开所有区域"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "编辑器装订线中折叠控件的颜色。",
"foldBackgroundBackground": "折叠范围后面的背景颜色。颜色必须设为透明，以免隐藏底层装饰。",
"foldingCollapsedIcon": "编辑器字形边距中已折叠的范围的图标。",
"foldingExpandedIcon": "编辑器字形边距中已展开的范围的图标。"
"foldingExpandedIcon": "编辑器字形边距中已展开的范围的图标。",
"foldingManualCollapedIcon": "编辑器字形边距中手动折叠的范围的图标。",
"foldingManualExpandedIcon": "编辑器字形边距中手动展开的范围的图标。"
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "放大编辑器字体",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "正在加载...",
"stopped rendering": "由于性能原因，长线的呈现已暂停。可通过`editor.stopRenderingLineAfter`配置此设置。",
"too many characters": "出于性能原因，未对长行进行解析。解析长度阈值可通过“editor.maxTokenizationLineLength”进行配置。"
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "查看问题"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "更改选项卡显示大小",
"configuredTabSize": "已配置制表符大小",
"currentTabSize": "当前选项卡大小",
"defaultTabSize": "默认选项卡大小",
"detectIndentation": "从内容中检测缩进方式",
"editor.reindentlines": "重新缩进行",
"editor.reindentselectedlines": "重新缩进所选行",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd + 点击"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "接受",
"acceptWord": "接受 Word",
"action.inlineSuggest.accept": "接受内联建议",
"action.inlineSuggest.acceptNextWord": "接受内联建议的下一个字",
"action.inlineSuggest.alwaysShowToolbar": "始终显示工具栏",
"action.inlineSuggest.hide": "隐藏内联建议",
"action.inlineSuggest.showNext": "显示下一个内联建议",
"action.inlineSuggest.showPrevious": "显示上一个内联建议",
"action.inlineSuggest.trigger": "触发内联建议",
"action.inlineSuggest.undo": "撤消接受 Word",
"alwaysShowInlineSuggestionToolbar": "内联建议工具栏是否应始终可见",
"canUndoInlineSuggestion": "撤消是否会撤消内联建议",
"inlineSuggestionHasIndentation": "内联建议是否以空白开头",
"inlineSuggestionHasIndentationLessThanTabSize": "内联建议是否以小于选项卡插入内容的空格开头",
"inlineSuggestionVisible": "内联建议是否可见"
"inlineSuggestionVisible": "内联建议是否可见",
"undoAcceptWord": "撤消接受 Word"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "建议:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "下一个",
"parameterHintsNextIcon": "“显示下一个参数”提示的图标。",
"parameterHintsPreviousIcon": "“显示上一个参数”提示的图标。",
"previous": "上一个"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "替换为下一个值",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "重复选择",
"editor.transformToCamelcase": "转换为驼峰式大小写",
"editor.transformToKebabcase": "转换为 Kebab 案例",
"editor.transformToLowercase": "转换为小写",
"editor.transformToSnakecase": "转换为蛇形命名法",
"editor.transformToTitlecase": "转换为词首字母大写",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "执行命令 {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "无法在只读编辑器中编辑",
"messageVisible": "编辑器当前是否正在显示内联消息"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "将上个选择内容移动到上一查找匹配项",
"mutlicursor.addCursorsToBottom": "在底部添加光标",
"mutlicursor.addCursorsToTop": "在顶部添加光标",
"mutlicursor.focusNextCursor": "聚焦下一个光标",
"mutlicursor.focusNextCursor.description": "聚焦下一个光标",
"mutlicursor.focusPreviousCursor": "聚焦上一个光标",
"mutlicursor.focusPreviousCursor.description": "聚焦上一个光标",
"mutlicursor.insertAbove": "在上面添加光标",
"mutlicursor.insertAtEndOfEachLineSelected": "在行尾添加光标",
"mutlicursor.insertBelow": "在下面添加光标",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "速览视图编辑器中装订线的背景色。",
"peekViewEditorMatchHighlight": "在速览视图编辑器中匹配突出显示颜色。",
"peekViewEditorMatchHighlightBorder": "在速览视图编辑器中匹配项的突出显示边框。",
"peekViewEditorStickScrollBackground": "速览视图编辑器中粘滞滚动的背景色。",
"peekViewResultsBackground": "速览视图结果列表背景色。",
"peekViewResultsFileForeground": "速览视图结果列表中文件节点的前景色。",
"peekViewResultsMatchForeground": "速览视图结果列表中行节点的前景色。",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "类型参数({0})",
"variable": "变量({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "无法在只读编辑器中编辑",
"editor.simple.readonly": "无法在只读输入中编辑"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "成功将“{0}”重命名为“{1}”。摘要: {2}",
"enablePreview": "启用/禁用重命名之前预览更改的功能",
"label": "正在重命名“{0}”",
"label": "正在将“{0}”重命名为“{1}”",
"no result": "无结果。",
"quotableLabel": "重命名 {0}",
"quotableLabel": "将 {0} 重命名为 {1}",
"rename.failed": "重命名无法计算修改",
"rename.failedApply": "重命名无法应用修改",
"rename.label": "重命名符号",
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "在代码片段模式下时是否存在下一制表位",
"hasPrevTabstop": "在代码片段模式下时是否存在上一制表位",
"inSnippetMode": "编辑器目前是否在代码片段模式下"
"inSnippetMode": "编辑器目前是否在代码片段模式下",
"next": "转到下一个占位符..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "四月",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "星期三",
"WednesdayShort": "周三"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "粘滞滚动(&&S)",
"mitoggleStickyScroll": "切换粘滞滚动(&&T)",
"stickyScroll": "粘滞滚动",
"toggleStickyScroll": "切换粘滞滚动"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "按 Enter 时是否会插入建议",
"suggestWidgetDetailsVisible": "建议详细信息是否可见",
"suggestWidgetHasSelection": "是否以任何建议为中心",
"suggestWidgetMultipleSuggestions": "是否存在多条建议可供选择",
"suggestionCanResolve": "当前建议是否支持解析更多详细信息",
"suggestionHasInsertAndReplaceRange": "当前建议是否具有插入和替换行为",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "建议小组件中的详细信息的图标。"
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "数组符号的前景色。这些符号将显示在大纲、痕迹导航栏和建议小组件中。",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "文件“{0}”包含一个或多个异常的行终止符，例如行分隔符(LS)或段落分隔符(PS)。\r\n\r\n建议从文件中删除它们。可通过“editor.unusualLineTerminators”进行配置。",
"unusualLineTerminators.fix": "删除异常行终止符",
"unusualLineTerminators.fix": "删除异常行终止符(&&R)",
"unusualLineTerminators.ignore": "忽略",
"unusualLineTerminators.message": "检测到异常行终止符",
"unusualLineTerminators.title": "异常行终止符"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "用于突出显示符号的概述标尺标记颜色。颜色必须透明，以免隐藏下面的修饰效果。",
"overviewRulerWordHighlightStrongForeground": "用于突出显示写权限符号的概述标尺标记颜色。颜色必须透明，以免隐藏下面的修饰效果。",
"overviewRulerWordHighlightTextForeground": "符号在文本中出现时的概述标尺标记颜色。颜色必须透明，以免隐藏下层的修饰。",
"wordHighlight": "读取访问期间符号的背景色，例如读取变量时。颜色必须透明，以免隐藏下面的修饰效果。",
"wordHighlight.next.label": "转到下一个突出显示的符号",
"wordHighlight.previous.label": "转到上一个突出显示的符号",
"wordHighlight.trigger.label": "触发符号高亮",
"wordHighlightBorder": "符号在进行读取访问操作时的边框颜色，例如读取变量。",
"wordHighlightStrong": "写入访问过程中符号的背景色，例如写入变量时。颜色必须透明，以免隐藏下面的修饰效果。",
"wordHighlightStrongBorder": "符号在进行写入访问操作时的边框颜色，例如写入变量。"
"wordHighlightStrongBorder": "符号在进行写入访问操作时的边框颜色，例如写入变量。",
"wordHighlightText": "符号在文本中出现时的背景色。颜色必须透明，以免隐藏下层的修饰。",
"wordHighlightTextBorder": "符号在文本中出现时的边框颜色。"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "转到下一个突出显示的符号",
"wordHighlight.previous.label": "转到上一个突出显示的符号",
"wordHighlight.trigger.label": "触发符号高亮"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "删除 Word"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "开发人员",
"help": "帮助",
"preferences": "首选项",
"test": "测试",
"view": "查看"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "隐藏",
"resetThisMenu": "重置菜单"
},
"vs/platform/actions/common/menuService": {
"hide.label": "隐藏“{0}”"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "操作小组件",
"customQuickFixWidget.labels": "{0}，禁用原因: {1}",
"label": "按 {0} 以应用",
"label-preview": "按 {0} 以应用，按 {1} 以预览"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "接受所选操作",
"codeActionMenuVisible": "操作小组件列表是否可见",
"hideCodeActionWidget.title": "隐藏操作小组件",
"previewSelected.title": "预览所选操作",
"selectNextCodeAction.title": "选择下一个操作",
"selectPrevCodeAction.title": "选择上一个操作"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "已删除差异行",
"audioCues.diffLineInserted": "已插入差异线",
"audioCues.diffLineModified": "差异行已修改",
"audioCues.lineHasBreakpoint.name": "行上的断点",
"audioCues.lineHasError.name": "行上的错误",
"audioCues.lineHasFoldedArea.name": "行上的折叠区域",
"audioCues.lineHasInlineSuggestion.name": "行上的内联建议",
"audioCues.lineHasWarning.name": "行上的警告",
"audioCues.noInlayHints": "行上无嵌入提示",
"audioCues.notebookCellCompleted": "笔记本单元格已完成",
"audioCues.notebookCellFailed": "笔记本单元格失败",
"audioCues.onDebugBreak.name": "调试程序已在断点处停止",
"audioCues.taskCompleted": "任务已完成",
"audioCues.taskFailed": "任务失败",
"audioCues.terminalBell": "终端钟",
"audioCues.terminalCommandFailed": "终端命令失败",
"audioCues.terminalQuickFix.name": "终端快速修复"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "无法注册 \"{0}\"。关联的策略 {1} 已向 {2} 注册。",
"config.property.duplicate": "无法注册“{0}”。此属性已注册。",
"config.property.empty": "无法注册空属性",
"config.property.languageDefault": "无法注册“{0}”。其符合描述特定语言编辑器设置的表达式 \"\\\\[.*\\\\]$\"。请使用 \"configurationDefaults\"。",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "操作系统是否为 Linux",
"isMac": "操作系统是否 macOS",
"isMacNative": "操作系统是否是非浏览器平台上的 macOS",
"isMobile": "平台是否为 Web 浏览器",
"isWeb": "平台是否为 Web 浏览器",
"isWindows": "操作系统是否为 Windows"
"isWindows": "操作系统是否为 Windows",
"productQualityType": "VS Code 的质量类型"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "取消",
"moreFile": "...1 个其他文件未显示",
"moreFiles": "...{0} 个其他文件未显示"
"moreFiles": "...{0} 个其他文件未显示",
"okButton": "确定(&&O)",
"yesButton": "是(&&Y)"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "文件太大，无法以无标题的编辑器形式打开。请先将其上传到文件资源管理器，然后重试。"
},
"vs/platform/files/common/files": {
"sizeB": "{0} B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "按下\"Alt\"时滚动速度倍增。",
"Mouse Wheel Scroll Sensitivity": "对鼠标滚轮滚动事件的 `deltaX` 和 `deltaY` 乘上的系数。",
"automatic keyboard navigation setting": "控制列表和树中的键盘导航是否仅通过键入自动触发。如果设置为 `false` ，键盘导航只在执行 `list.toggleKeyboardNavigation` 命令时触发，您可以为该命令指定键盘快捷方式。",
"defaultFindMatchTypeSettingKey": "控制在工作台中搜索列表和树时使用的匹配类型。",
"defaultFindMatchTypeSettingKey.contiguous": "在搜索时使用连续匹配。",
"defaultFindMatchTypeSettingKey.fuzzy": "在搜索时使用模糊匹配。",
"defaultFindModeSettingKey": "控制工作台中列表和树的默认查找模式。",
"defaultFindModeSettingKey.filter": "搜索时筛选元素。",
"defaultFindModeSettingKey.highlight": "搜索时突出显示元素。进一步向上和向下导航将仅遍历突出显示的元素。",
"expand mode": "控制在单击文件夹名称时如何扩展树文件夹。请注意，如果不适用，某些树和列表可能会选择忽略此设置。",
"horizontalScrolling setting": "控制列表和树是否支持工作台中的水平滚动。警告: 打开此设置影响会影响性能。",
"keyboardNavigationSettingKey": "控制工作台中的列表和树的键盘导航样式。它可为“简单”、“突出显示”或“筛选”。",
"keyboardNavigationSettingKey.filter": "筛选器键盘导航将筛选出并隐藏与键盘输入不匹配的所有元素。",
"keyboardNavigationSettingKey.highlight": "高亮键盘导航会突出显示与键盘输入相匹配的元素。进一步向上和向下导航将仅遍历突出显示的元素。",
"keyboardNavigationSettingKey.simple": "简单键盘导航聚焦与键盘输入相匹配的元素。仅对前缀进行匹配。",
"keyboardNavigationSettingKeyDeprecated": "请改用 \"workbench.list.defaultFindMode\" 和 \"workbench.list.typeNavigationMode\"。",
"list smoothScrolling setting": "控制列表和树是否具有平滑滚动效果。",
"list.scrollByPage": "控制在滚动条中单击时是否逐页单击。",
"multiSelectModifier": "在通过鼠标多选树和列表条目时使用的修改键 (例如“资源管理器”、“打开的编辑器”和“源代码管理”视图)。“在侧边打开”功能所需的鼠标动作 (若可用) 将会相应调整，不与多选修改键冲突。",
"multiSelectModifier.alt": "映射为 `Alt` (Windows 和 Linux) 或 `Option` (macOS)。",
"multiSelectModifier.ctrlCmd": "映射为 `Ctrl` (Windows 和 Linux) 或 `Command` (macOS)。",
"openModeModifier": "控制如何使用鼠标打开树和列表中的项(若支持)。请注意，如果此设置不适用，某些树和列表可能会选择忽略它。",
"render tree indent guides": "控制树是否应呈现缩进参考线。",
"tree indent setting": "控制树缩进(以像素为单位)。",
"typeNavigationMode": "控制类型导航在工作台的列表和树中的工作方式。如果设置为 \"trigger\"，则在运行 \"list.triggerTypeNavigation\" 命令后，类型导航将开始。",
"workbenchConfigurationTitle": "工作台"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "警告"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "命令\"{0}\"导致错误 ({1})",
"canNotRun": "命令 \"{0}\" 导致错误",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "常用",
"morecCommands": "其他命令",
"recentlyUsed": "最近使用"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "编辑器命令",
"globalCommands": "全局命令",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "自定义",
"inputModeEntry": "按 \"Enter\" 以确认或按 \"Esc\" 以取消",
"inputModeEntryDescription": "{0} (按 \"Enter\" 以确认或按 \"Esc\" 以取消)",
"ok": "确定",
"quickInput.back": "上一步",
"quickInput.backWithKeybinding": "后退 ({0})",
"quickInput.checkAll": "切换所有复选框",
"quickInput.countSelected": "已选 {0} 项",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} 个结果",
"quickInputBox.ariaLabel": "在此输入可缩小结果范围。"
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "快速输入"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "单击以执行命令 \"{0}\""
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "在活动元素周围额外的一层边框，用来提高对比度从而区别其他元素。",
"activeLinkForeground": "活动链接颜色。",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "导航路径项的背景色。",
"breadcrumbsFocusForeground": "焦点导航路径的颜色",
"breadcrumbsSelectedBackground": "导航路径项选择器的背景色。",
"breadcrumbsSelectedForegound": "已选导航路径项的颜色。",
"breadcrumbsSelectedForeground": "已选导航路径项的颜色。",
"buttonBackground": "按钮背景色。",
"buttonBorder": "按钮边框颜色。",
"buttonForeground": "按钮前景色。",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "辅助按钮背景色。",
"buttonSecondaryForeground": "辅助按钮前景色。",
"buttonSecondaryHoverBackground": "悬停时的辅助按钮背景色。",
"buttonSeparator": "按钮分隔符颜色。",
"chartsBlue": "图表可视化效果中使用的蓝色。",
"chartsForeground": "图表中使用的前景颜色。",
"chartsGreen": "图表可视化效果中使用的绿色。",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "复选框小部件的背景颜色。",
"checkbox.border": "复选框小部件的边框颜色。",
"checkbox.foreground": "复选框小部件的前景色。",
"checkbox.select.background": "选择复选框小组件所在的元素时该小组件的背景色。",
"checkbox.select.border": "选择复选框小组件所在的元素时该小组件的边框颜色。",
"contrastBorder": "在元素周围额外的一层边框，用来提高对比度从而区别其他元素。",
"descriptionForeground": "提供其他信息的说明文本的前景色，例如标签文本。",
"diffDiagonalFill": "差异编辑器的对角线填充颜色。对角线填充用于并排差异视图。",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "删除行的边距的背景色。",
"diffEditorRemovedLines": "已删除的行的背景色。颜色必须透明，以免隐藏下面的修饰效果。",
"diffEditorRemovedOutline": "被删除文本的轮廓颜色。",
"disabledForeground": "已禁用元素的整体前景色。仅在未由组件替代时才能使用此颜色。",
"dropdownBackground": "下拉列表背景色。",
"dropdownBorder": "下拉列表边框。",
"dropdownForeground": "下拉列表前景色。",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "用以彰显高对比度的所选文本的颜色。",
"editorSelectionHighlight": "具有与所选项相关内容的区域的颜色。颜色必须透明，以免隐藏下面的修饰效果。",
"editorSelectionHighlightBorder": "与所选项内容相同的区域的边框颜色。",
"editorStickyScrollBackground": "编辑器的粘滞滚动背景色",
"editorStickyScrollHoverBackground": "编辑器悬停背景色上的粘滞滚动",
"editorWarning.background": "编辑器中警告文本的背景色。颜色必须透明，以免隐藏下面的修饰效果。",
"editorWarning.foreground": "编辑器中警告波浪线的前景色。",
"editorWidgetBackground": "编辑器组件(如查找/替换)背景颜色。",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "列表和树中类型筛选器小组件的背景色。",
"listFilterWidgetNoMatchesOutline": "当没有匹配项时，列表和树中类型筛选器小组件的轮廓颜色。",
"listFilterWidgetOutline": "列表和树中类型筛选器小组件的轮廓颜色。",
"listFilterWidgetShadow": "列表和树中类型筛选器小组件的阴影颜色。",
"listFocusAndSelectionOutline": "当列表/树处于活动状态且已选择时，重点项的列表/树边框颜色。活动的列表/树具有键盘焦点，但非活动的则没有。",
"listFocusBackground": "焦点项在列表或树活动时的背景颜色。活动的列表或树具有键盘焦点，非活动的没有。",
"listFocusForeground": "焦点项在列表或树活动时的前景颜色。活动的列表或树具有键盘焦点，非活动的没有。",
"listFocusHighlightForeground": "在列表或树中搜索时，匹配活动聚焦项的突出显示内容的列表/树前景色。",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "将鼠标悬停在操作上时的工具栏背景",
"toolbarHoverBackground": "使用鼠标悬停在操作上时显示工具栏背景",
"toolbarHoverOutline": "使用鼠标悬停在操作上时显示工具栏轮廓",
"treeInactiveIndentGuidesStroke": "非活动缩进参考线的树描边颜色。",
"treeIndentGuidesStroke": "缩进参考线的树描边颜色。",
"warningBorder": "编辑器中警告框的边框颜色。",
"widgetBorder": "编辑器内小组件(如查找/替换)的边框颜色。",
"widgetShadow": "编辑器内小组件(如查找/替换)的阴影颜色。"
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "小组件中“关闭”操作的图标。"
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "取消",
"cannotResourceRedoDueToInProgressUndoRedo": "无法重做“{0}”，因为已有一项撤消或重做操作正在运行。",
"cannotResourceUndoDueToInProgressUndoRedo": "无法撤销“{0}”，因为已有一项撤消或重做操作正在运行。",
"cannotWorkspaceRedo": "无法在所有文件中重做“{0}”。{1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "无法跨所有文件撤销“{0}”，因为 {1} 上已有一项撤消或重做操作正在运行",
"confirmDifferentSource": "是否要撤消“{0}”?",
"confirmDifferentSource.no": "否",
"confirmDifferentSource.yes": "是",
"confirmDifferentSource.yes": "是(&&Y)",
"confirmWorkspace": "是否要在所有文件中撤消“{0}”?",
"externalRemoval": "以下文件已关闭并且已在磁盘上修改: {0}。",
"noParallelUniverses": "以下文件已以不兼容的方式修改: {0}。",
"nok": "撤消此文件",
"ok": "在 {0} 个文件中撤消"
"nok": "撤消此文件(&&F)",
"ok": "在 {0} 个文件中撤消(&&U)"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Code 工作区"

394
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/locale/zh-hant.js vendored
View File

@ -5,9 +5,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/actionbar/actionViewItems": {
"titleLabel": "{0} ({1})"
},
"vs/base/browser/ui/button/button": {
"button dropdown more actions": "更多動作..."
},
"vs/base/browser/ui/dialog/dialog": {
"dialogClose": "關閉對話方塊",
"dialogErrorMessage": "錯誤",
"dialogInfoMessage": "資訊",
"dialogPendingMessage": "進行中",
"dialogWarningMessage": "警告",
"ok": "確定"
},
"vs/base/browser/ui/dropdown/dropdownActionViewItem": {
"moreActions": "更多動作..."
},
"vs/base/browser/ui/findinput/findInput": {
"defaultLabel": "輸入"
},
"vs/base/browser/ui/findinput/findInputToggles": {
"caseDescription": "大小寫須相符",
"regexDescription": "使用規則運算式",
"wordsDescription": "全字拼寫須相符"
},
"vs/base/browser/ui/findinput/replaceInput": {
"defaultLabel": "輸入",
"label.preserveCaseToggle": "保留案例"
@ -24,12 +43,19 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/base/browser/ui/keybindingLabel/keybindingLabel": {
"unbound": "未繫結"
},
"vs/base/browser/ui/selectBox/selectBoxCustom": {
"selectBox": "選取方塊"
},
"vs/base/browser/ui/toolbar/toolbar": {
"moreActions": "更多操作"
},
"vs/base/browser/ui/tree/abstractTree": {
"clear": "清除",
"disable filter on type": "在類型上停用篩選",
"empty": "找不到任何元素",
"enable filter on type": "在類型上啟用篩選",
"found": "{1} 項元素中有 {0} 項相符"
"close": "關閉",
"filter": "篩選",
"fuzzySearch": "模糊比對",
"not found": "找不到任何元素。",
"type to filter": "要篩選的類型",
"type to search": "要搜尋的類型"
},
"vs/base/common/actions": {
"submenu.empty": "(空的)"
@ -54,20 +80,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"windowsKey": "Windows",
"windowsKey.long": "Windows"
},
"vs/base/parts/quickinput/browser/quickInput": {
"custom": "自訂",
"inputModeEntry": "按 'Enter' 鍵確認您的輸入或按 'Esc' 鍵取消",
"inputModeEntryDescription": "{0} (按 'Enter' 鍵確認或按 'Esc' 鍵取消)",
"ok": "確定",
"quickInput.back": "上一頁",
"quickInput.backWithKeybinding": "背面 ({0})",
"quickInput.countSelected": "已選擇 {0}",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} 個結果",
"quickInputBox.ariaLabel": "輸入以縮小結果範圍。"
},
"vs/base/parts/quickinput/browser/quickInputList": {
"quickInput": "快速輸入"
"vs/base/common/platform": {
"ensureLoaderPluginIsLoaded": "_"
},
"vs/editor/browser/controller/textAreaHandler": {
"accessibilityOffAriaLabel": "目前無法存取此編輯器。請按 {0} 取得選項。",
@ -86,9 +100,11 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"undo": "復原"
},
"vs/editor/browser/widget/codeEditorWidget": {
"cursors.maximum": "游標數已限制為 {0} 個。"
"cursors.maximum": "游標數目已限制為 {0}。請考慮使用 [尋找和取代](https://code.visualstudio.com/docs/editor/codebasics#_find-and-replace) 進行較大型的變更，或增加編輯器的多重游標限制設定。",
"goToSetting": "增加多重游標限制"
},
"vs/editor/browser/widget/diffEditorWidget": {
"diff-aria-navigation-tip": " 使用 Shift + F7 瀏覽變更",
"diff.tooLarge": "因其中一個檔案過大而無法比較。",
"diffInsertIcon": "Diff 編輯器中用於插入的線條裝飾。",
"diffRemoveIcon": "Diff 編輯器中用於移除的線條裝飾。"
@ -121,15 +137,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/common/config/editorConfigurationSchema": {
"codeLens": "控制編輯器是否顯示 codelens。",
"detectIndentation": "根據檔案內容，控制當檔案開啟時，是否自動偵測 `#editor.tabSize#` 和 `#editor.insertSpaces#`。",
"detectIndentation": "根據檔案內容，控制當檔案開啟時，是否自動偵測 {0} 和 {1}。",
"diffAlgorithm.experimental": "使用實驗性差異演算法。",
"diffAlgorithm.smart": "使用預設的差異演算法。",
"editor.experimental.asyncTokenization": "控制權杖化是否應該在 Web 工作者上非同步進行。",
"editorConfigurationTitle": "編輯器",
"ignoreTrimWhitespace": "啟用時，Diff 編輯器會忽略前置或後置空格的變更。",
"insertSpaces": "在按 `Tab` 時插入空格。當 `#editor.detectIndentation#` 開啟時，會根據檔案內容覆寫此設定。",
"indentSize": "用於縮排或 'tabSize' 使用 `\"editor.tabSize\"` 值的空格數目。當 '#editor.detectIndentation#' 開啟時，會根據檔案內容覆寫這個設定。",
"insertSpaces": "在按 `Tab` 時插入空格。當 {0} 開啟時，會根據檔案內容覆寫此設定。",
"largeFileOptimizations": "針對大型檔案停用部分高記憶體需求功能的特殊處理方式。",
"maxComputationTime": "取消 Diff 計算前的逾時限制 (毫秒)。若無逾時，請使用 0。",
"maxFileSize": "要計算差異的檔案大小上限 (MB)。使用 0 表示無限制。",
"maxTokenizationLineLength": "因效能的緣故，不會將超過此高度的行 Token 化",
"renderIndicators": "控制 Diff 編輯器是否要為新增/移除的變更顯示 +/- 標記。",
"renderMarginRevertIcon": "啟用時，Diff 編輯器會在其字符邊緣顯示箭頭，以還原變更。",
"schema.brackets": "定義增加或減少縮排的括弧符號。",
"schema.closeBracket": "右括弧字元或字串順序。",
"schema.colorizedBracketPairs": "定義當括弧配對著色已啟用時，由其巢狀層級著色的括弧配對。",
@ -140,26 +161,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"semanticHighlighting.true": "所有彩色主題皆已啟用語意醒目提示。",
"sideBySide": "控制 Diff 編輯器要並排或內嵌顯示 Diff。",
"stablePeek": "即使按兩下內容或按 `Escape`，仍保持瞄孔編輯器開啟。",
"tabSize": "與 Tab 相等的空格數量。當 `#editor.detectIndentation#` 已開啟時，會根據檔案內容覆寫此設定。",
"tabSize": "與 Tab 相等的空格數量。當 {0} 已開啟時，會根據檔案內容覆寫此設定。",
"trimAutoWhitespace": "移除尾端自動插入的空白字元。",
"wordBasedSuggestions": "控制是否應根據文件中的單字計算自動完成。",
"wordBasedSuggestionsMode": "控制要從哪些文件計算以字組為基礎的完成作業。",
"wordBasedSuggestionsMode.allDocuments": "建議來自所有已開啟文件中的字組。",
"wordBasedSuggestionsMode.currentDocument": "僅建議來自使用中文件中的字組。",
"wordBasedSuggestionsMode.matchingDocuments": "建議來自所有已開啟文件中，語言相同的字組。",
"wordWrap.inherit": "將依據 `#editor.wordWrap#` 設定自動換行。",
"wordWrap.inherit": "將依據 {0} 設定自動換行。",
"wordWrap.off": "一律不換行。",
"wordWrap.on": "依檢視區寬度換行。"
},
"vs/editor/common/config/editorOptions": {
"acceptSuggestionOnCommitCharacter": "控制是否透過認可字元接受建議。例如在 JavaScript 中，分號 (';') 可以是接受建議並鍵入該字元的認可字元。",
"acceptSuggestionOnCommitCharacter": "控制是否透過提交字元接受建議。例如在 JavaScript 中，分號 (';') 可以是接受建議並鍵入該字元的提交字元。",
"acceptSuggestionOnEnter": "控制除了 'Tab' 外，是否也透過 'Enter' 接受建議。這有助於避免混淆要插入新行或接受建議。",
"acceptSuggestionOnEnterSmart": "在建議進行文字變更時，僅透過 `Enter` 接受建議。",
"accessibilityPageSize": "控制編輯器中可一次由螢幕助讀程式讀出的行數。偵測到螢幕助讀程式時會自動預設為 500。警告: 若數字超過預設，可能會對效能有所影響。",
"accessibilitySupport": "控制編輯器是否應於已為螢幕助讀程式最佳化的模式中執行。設定為開啟會停用自動換行。",
"accessibilitySupport.auto": "編輯器將使用平台 API 以偵測螢幕助讀程式附加。",
"accessibilitySupport.off": "編輯器不會為螢幕助讀程式的使用方式進行最佳化。",
"accessibilitySupport.on": "編輯器將一律最佳化以用於螢幕助讀程式。自動換行將會停用。",
"accessibilitySupport": "控制 UI 是否應於已為螢幕助讀程式最佳化的模式中執行。",
"accessibilitySupport.auto": "使用平台 API 以偵測螢幕助讀程式附加",
"accessibilitySupport.off": "假設未附加螢幕助讀程式",
"accessibilitySupport.on": "使用螢幕助讀程式最佳化使用方式",
"alternativeDeclarationCommand": "當 'Go to Declaration' 的結果為目前位置時，正在執行的替代命令識別碼。",
"alternativeDefinitionCommand": "當 'Go to Definition' 的結果為目前位置時，正在執行的替代命令識別碼。",
"alternativeImplementationCommand": "當 'Go to Implementation' 的結果為目前位置時，正在執行的替代命令識別碼。",
@ -171,21 +192,25 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"autoClosingQuotes": "控制編輯器是否應在使用者新增開始引號後，自動加上關閉引號。",
"autoIndent": "控制編輯器是否應在使用者鍵入、貼上、移動或縮排行時自動調整縮排。",
"autoSurround": "控制編輯器是否應在鍵入引號或括弧時自動包圍選取範圍。",
"bracketPairColorization.enabled": "控制是否啟用成對方括弧著色。使用 `#workbench.colorCustomizations#` 覆寫括弧亮顯顏色。",
"bracketPairColorization.enabled": "控制是否啟用成對方括弧著色。使用 {0} 覆寫括弧亮顯顏色。",
"bracketPairColorization.independentColorPoolPerBracketType": "控制每個括弧類型是否有自己的獨立色彩集區。",
"codeActions": "在編輯器中啟用程式碼動作燈泡。",
"codeLens": "控制編輯器是否顯示 codelens。",
"codeLensFontFamily": "控制 CodeLens 的字型家族。",
"codeLensFontSize": "控制 CodeLens 的字型大小 (像素)。設定為 `0` 時，會使用 90% 的 '#editor.fontSize#'。",
"codeLensFontSize": "控制 CodeLens 的字型大小 (像素)。設定為 0 時，會使用 90% 的 `#editor.fontSize#`。",
"colorDecorators": "控制編輯器是否應轉譯內嵌色彩裝飾項目與色彩選擇器。",
"colorDecoratorsLimit": "控制一次可在編輯器中呈現的色彩裝飾項目最大數目。",
"columnSelection": "啟用即可以滑鼠與按鍵選取進行資料行選取。",
"comments.ignoreEmptyLines": "控制是否應以行註解的切換、新增或移除動作，忽略空白的行。",
"comments.insertSpace": "控制是否要在註解時插入空白字元。",
"copyWithSyntaxHighlighting": "控制語法醒目提示是否應複製到剪貼簿。",
"cursorBlinking": "控制資料指標動畫樣式。",
"cursorSmoothCaretAnimation": "控制是否應啟用平滑插入點動畫。 ",
"cursorSmoothCaretAnimation.explicit": "只有當使用者使用明確手勢移動游標時，才會啟用平滑插入號動畫。",
"cursorSmoothCaretAnimation.off": "平滑插入號動畫已停用。",
"cursorSmoothCaretAnimation.on": "永遠啟用平滑插入號動畫。",
"cursorStyle": "控制資料指標樣式。",
"cursorSurroundingLines": "控制游標上下周圍可顯示的最少行數。在某些編輯器中稱為 'scrollOff' 或 'scrollOffset'。",
"cursorSurroundingLines": "控制游標上下周圍可顯示的前置線 (最小為 0) 和後置線 (最小為 1) 的最小數目。在某些編輯器中稱為 'scrollOff' 或 'scrollOffset'。",
"cursorSurroundingLinesStyle": "控制應施行 `cursorSurroundingLines` 的時機。",
"cursorSurroundingLinesStyle.all": "一律強制執行 `cursorSurroundingLines`",
"cursorSurroundingLinesStyle.default": "只有通過鍵盤或 API 觸發時，才會施行 `cursorSurroundingLines`。",
@ -193,6 +218,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"definitionLinkOpensInPeek": "控制「前往定義」滑鼠手勢，是否一律開啟瞄核小工具。",
"deprecated": "此設定已淘汰，請改用 'editor.suggest.showKeywords' 或 'editor.suggest.showSnippets' 等單獨設定。",
"dragAndDrop": "控制編輯器是否允許透過拖放來移動選取項目。",
"dropIntoEditor.enabled": "控制您是否可以按住 `shift` 鍵 (而非在編輯器中開啟檔案)，將檔案拖放到文字編輯器中。",
"editor.autoClosingBrackets.beforeWhitespace": "僅當游標位於空白的左側時自動關閉括號。",
"editor.autoClosingBrackets.languageDefined": "使用語言配置確定何時自動關閉括號。",
"editor.autoClosingDelete.auto": "僅在自動插入相鄰的右引號或括弧時，才將其移除。",
@ -232,7 +258,17 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.guides.bracketPairsHorizontal.true": "啟用水平輔助線作為垂直括弧配對輔助線的新增功能。",
"editor.guides.highlightActiveBracketPair": "控制編輯器是否應醒目提示使用中的成對括弧。",
"editor.guides.highlightActiveIndentation": "控制編輯器是否應醒目提示使用中的縮排輔助線。",
"editor.guides.highlightActiveIndentation.always": "即使醒目提示括弧輔助線，仍醒目提示使用中的縮排輔助線。",
"editor.guides.highlightActiveIndentation.false": "不要醒目提示使用中的縮排輔助線。",
"editor.guides.highlightActiveIndentation.true": "醒目提示使用中的縮排輔助線。",
"editor.guides.indentation": "控制編輯器是否應顯示縮排輔助線。",
"editor.inlayHints.off": "已停用內嵌提示",
"editor.inlayHints.offUnlessPressed": "預設會隱藏內嵌提示，並在按住 {0} 時顯示",
"editor.inlayHints.on": "已啟用內嵌提示",
"editor.inlayHints.onUnlessPressed": "預設會顯示內嵌提示，並在按住 {0} 時隱藏",
"editor.stickyScroll": "在編輯器頂端捲動期間顯示巢狀的目前範圍。",
"editor.stickyScroll.": "定義要顯示的自黏線數目上限。",
"editor.suggest.matchOnWordStartOnly": "啟用時，IntelliSense 篩選會要求第一個字元符合文字開頭，例如 `Console` 或 `WebCoNtext` 上的 `c`，但不是 `description` 上的 _not_。停用時，IntelliSense 會顯示更多結果，但仍會依相符品質排序結果。",
"editor.suggest.showClasss": "啟用時，IntelliSense 顯示「類別」建議。",
"editor.suggest.showColors": "啟用時，IntelliSense 顯示「色彩」建議。",
"editor.suggest.showConstants": "啟用時，IntelliSense 顯示「常數」建議。",
@ -264,6 +300,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editor.suggest.showVariables": "啟用時，IntelliSense 顯示「變數」建議。",
"editorViewAccessibleLabel": "編輯器內容",
"emptySelectionClipboard": "控制複製時不選取任何項目是否會複製目前程式行。",
"experimentalWhitespaceRendering": "控制是否使用新的實驗性方法來呈現空白字元。",
"experimentalWhitespaceRendering.font": "使用具有字型字元的新轉譯方法。",
"experimentalWhitespaceRendering.off": "使用穩定轉譯方法。",
"experimentalWhitespaceRendering.svg": "使用新的 svg 轉譯方法。",
"fastScrollSensitivity": "按下 `Alt` 時的捲動速度乘數。",
"find.addExtraSpaceOnTop": "控制尋找小工具是否應在編輯器頂端額外新增行。若為 true，當您可看到尋找小工具時，您的捲動範圍會超過第一行。",
"find.autoFindInSelection": "控制自動開啟 [在選取範圍中尋找] 的條件。",
@ -283,6 +323,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"fontLigatures": "啟用/停用連字字型 ('calt' 和 'liga' 字型功能)。將此項變更為字串，以精確控制 'font-feature-settings' CSS 屬性。",
"fontLigaturesGeneral": "設定連字字型或字型功能。可以是布林值以啟用/停用連字，或代表 CSS 'font-feature-settings' 屬性的字串。",
"fontSize": "控制字型大小 (像素)。",
"fontVariationSettings": "明確的 'font-variation-settings' CSS 屬性。如果只需要將 font-weight 轉換為 font-variation-settings，可以改為傳遞布林值。",
"fontVariations": "啟用/停用從 font-weight 到 font-variation-settings 的轉換。將此設定變更為字串，以更精細地控制 'font-variation-settings' CSS 屬性。",
"fontVariationsGeneral": "設定字型變化。可以是布林值，以啟用/停用從 font-weight 到 font-variation-settings 的轉換，或是字串，做為 CSS 'font-variation-settings' 屬性的值。",
"fontWeight": "控制字型粗細。接受「一般」及「粗體」關鍵字，或介於 1 到 1000 之間的數值。",
"fontWeightErrorMessage": "只允許「一般」及「粗體」關鍵字，或介於 1 到 1000 之間的數值。",
"formatOnPaste": "控制編輯器是否應自動為貼上的內容設定格式。必須有可用的格式器，而且格式器應能夠為文件中的一個範圍設定格式。",
@ -294,10 +337,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"hover.enabled": "控制是否顯示暫留。",
"hover.sticky": "控制當滑鼠移過時，是否應保持顯示暫留。",
"inlayHints.enable": "啟用編輯器中的內嵌提示。",
"inlayHints.fontFamily": "控制編輯器中，內嵌提示的字型家族。設定為空白時，會使用 `#editor.fontFamily#`。",
"inlayHints.fontSize": "控制編輯器中內嵌提示的字型大小。當設定的值小於 '5' 或大於編輯器字型大小時，會使用 90% 的 '#editor.fontSize#' 預設值。",
"inlayHints.fontFamily": "控制編輯器中，內嵌提示的字型家族。設定為空白時，則會使用 {0}。",
"inlayHints.fontSize": "控制編輯器中內嵌提示的字型大小。當設定的值小於 {1} 或大於編輯器字型大小時，則會使用{0} 預設值。",
"inlayHints.padding": "在編輯器中啟用的內嵌提示周圍的填補。",
"inline": "快速建議會顯示為浮水印文字",
"inlineSuggest.enabled": "控制是否要在編輯器中自動顯示內嵌建議。",
"inlineSuggest.showToolbar": "控制何時顯示內嵌建議工具列。",
"inlineSuggest.showToolbar.always": "每當顯示內嵌建議時，顯示內嵌建議工具列。",
"inlineSuggest.showToolbar.onHover": "每當游標停留在內嵌建議上方時，顯示內嵌建議工具列。",
"letterSpacing": "控制字母間距 (像素)。",
"lineHeight": "控制行高。\r\n - 使用 0 從字型大小自動計算行高。\r\n - 使用介於 0 和 8 之間的值作為字型大小的乘數。\r\n - 大於或等於 8 的值將用來作為有效值。",
"lineNumbers": "控制行號的顯示。",
@ -308,6 +355,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"linkedEditing": "控制編輯器是否已啟用連結編輯。相關符號 (例如 HTML 標籤) 會根據語言在編輯時更新。",
"links": "控制編輯器是否應偵測連結並使其可供點選。",
"matchBrackets": "將符合的括號醒目提示。",
"minimap.autohide": "控制是否會自動隱藏縮圖。",
"minimap.enabled": "控制是否會顯示縮圖",
"minimap.maxColumn": "限制縮圖的寬度，最多顯示某個數目的列。",
"minimap.renderCharacters": "顯示行中的實際字元，而不是色彩區塊。",
@ -320,8 +368,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"minimap.size.proportional": "縮圖大小與編輯器內容相同 (且可能會捲動)。",
"mouseWheelScrollSensitivity": "要用於滑鼠滾輪捲動事件 `deltaX` 和 `deltaY` 的乘數。",
"mouseWheelZoom": "使用滑鼠滾輪並按住 `Ctrl` 時，縮放編輯器的字型",
"multiCursorLimit": "控制一次可在作用中編輯器中的游標數目上限。",
"multiCursorMergeOverlapping": "在多個游標重疊時將其合併。",
"multiCursorModifier": "用於在滑鼠新增多個游標的乘數。「移至定義」和「開啟連結」滑鼠手勢會加以適應，以避免與多個游標的乘數相衝突。[深入了解](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier)。",
"multiCursorModifier": "用於在滑鼠新增多個游標的修飾元。[移至定義] 和 [開啟連結] 滑鼠手勢會加以適應，以避免與 [多個游標的修飾元](https://code.visualstudio.com/docs/editor/codebasics#_multicursor-modifier) 相衝突。",
"multiCursorModifier.alt": "對應Windows和Linux的'Alt'與對應macOS的'Option'。",
"multiCursorModifier.ctrlCmd": "對應Windows和Linux的'Control'與對應 macOS 的'Command'。",
"multiCursorPaste": "當已貼上文字的行數與游標數相符時控制貼上功能。",
@ -338,7 +387,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekWidgetDefaultFocus": "控制要聚焦內嵌編輯器或預覽小工具中的樹系。",
"peekWidgetDefaultFocus.editor": "開啟時聚焦編輯器",
"peekWidgetDefaultFocus.tree": "開啟預覽時焦點樹狀",
"quickSuggestions": "控制是否應在鍵入時自動顯示建議。",
"quickSuggestions": "控制輸入時是否應自動顯示建議。這可控制在註解、字串及其他程式碼中的輸入。可設定快速建議以隱形浮出文字或建議小工具顯示。另外也請注意 '{0}'-設定，其會控制建議是否由特殊字元所觸發。",
"quickSuggestions.comments": "允許在註解中顯示即時建議。",
"quickSuggestions.other": "允許在字串與註解以外之處顯示即時建議。",
"quickSuggestions.strings": "允許在字串內顯示即時建議。",
@ -379,6 +428,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"showFoldingControls": "控制摺疊控制項在裝訂邊上的顯示時機。",
"showFoldingControls.always": "一律顯示摺疊控制項。",
"showFoldingControls.mouseover": "僅當滑鼠懸停在活動列上時，才顯示折疊功能。",
"showFoldingControls.never": "永不顯示摺疊控制項與減少裝訂邊大小。",
"showUnused": "控制未使用程式碼的淡出。",
"smoothScrolling": "控制編輯器是否會使用動畫捲動",
"snippetSuggestions": "控制程式碼片段是否隨其他建議顯示，以及其排序方式。",
@ -389,18 +439,23 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"stickyTabStops": "當使用空格進行縮排時，會模擬定位字元的選取表現方式。選取範圍會依循定位停駐點。",
"suggest.filterGraceful": "控制對於拚錯字是否進行篩選和排序其建議",
"suggest.insertMode": "控制是否要在接受完成時覆寫字組。請注意，這取決於加入此功能的延伸模組。",
"suggest.insertMode.always": "自動觸發 IntelliSense 時一律選取建議。",
"suggest.insertMode.insert": "插入建議而不覆寫游標旁的文字。",
"suggest.insertMode.never": "自動觸發 IntelliSense 時永不選取建議。",
"suggest.insertMode.replace": "插入建議並覆寫游標旁的文字。",
"suggest.insertMode.whenQuickSuggestion": "只有在您輸入時觸發 IntelliSense 時，才選取建議。",
"suggest.insertMode.whenTriggerCharacter": "只有在從觸發字元觸發 IntelliSense 時，才選取建議。",
"suggest.localityBonus": "控制排序是否偏好游標附近的字組。",
"suggest.maxVisibleSuggestions.dep": "此設定已淘汰。建議小工具現可調整大小。",
"suggest.preview": "控制是否要在編輯器中預覽建議結果。",
"suggest.selectionMode": "控制小工具顯示時是否選取建議。請注意，這只適用於('#editor.quickSuggestions#' 和 '#editor.suggestOnTriggerCharacters#') 自動觸發的建議，而且一律會在明確叫用時選取建議，例如透過 'Ctrl+Space'。",
"suggest.shareSuggestSelections": "控制記錄的建議選取項目是否在多個工作區和視窗間共用 (需要 `#editor.suggestSelection#`)。",
"suggest.showIcons": "控制要在建議中顯示或隱藏圖示。",
"suggest.showInlineDetails": "控制建議詳細資料是以內嵌於標籤的方式顯示，還是只在詳細資料小工具中顯示",
"suggest.showInlineDetails": "控制建議詳細資料是以內嵌於標籤的方式顯示，還是只在詳細資料小工具中顯示。",
"suggest.showStatusBar": "控制建議小工具底下的狀態列可見度。",
"suggest.snippetsPreventQuickSuggestions": "控制正在使用的程式碼片段是否會避免快速建議。",
"suggestFontSize": "建議小工具的字型大小。當設定為 `0` 時，則使用 `#editor.fontSize#` 值.",
"suggestLineHeight": "建議小工具的行高。當設定為 `0` 時，則使用 `#editor.lineHeight#` 的值。最小值為 8。",
"suggestFontSize": "建議小工具的字型大小。當設定為 {0} 時，則會使用 {1} 的值。",
"suggestLineHeight": "建議小工具的行高。當設定為 {0} 時，則會使用 {1} 的值。最小值為 8。",
"suggestOnTriggerCharacters": "控制建議是否應在鍵入觸發字元時自動顯示。",
"suggestSelection": "控制在顯示建議清單時如何預先選取建議。",
"suggestSelection.first": "一律選取第一個建議。",
@ -410,6 +465,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabCompletion.off": "停用 tab 鍵自動完成。",
"tabCompletion.on": "按 Tab 時，Tab 完成會插入最符合的建議。",
"tabCompletion.onlySnippets": "在程式碼片段的首碼相符時使用 Tab 完成。未啟用 'quickSuggestions' 時效果最佳。",
"tabFocusMode": "控制編輯器是否接收索引標籤，或將其延遲至工作台進行流覽。",
"unfoldOnClickAfterEndOfLine": "控制按一下已折疊行後方的空白內容是否會展開行。",
"unicodeHighlight.allowedCharacters": "定義未醒目提示的允許字元。",
"unicodeHighlight.allowedLocales": "不會將允許地區設置中常見的 Unicode 字元強調顯示。",
@ -423,6 +479,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unusualLineTerminators.off": "忽略異常的行結束字元。",
"unusualLineTerminators.prompt": "要移除之異常的行結束字元提示。",
"useTabStops": "插入和刪除接在定位停駐點後的空白字元。",
"wordBreak": "控制用於中文/日文/韓文 (CJK) 文字的斷字規則。",
"wordBreak.keepAll": "中文/日文/韓文 (CJK) 文字不應該使用斷字。非中日韓的文字行為與一般文字相同。",
"wordBreak.normal": "使用預設的分行符號規則。",
"wordSeparators": "在執行文字相關導覽或作業時要用作文字分隔符號的字元",
"wordWrap": "控制如何換行。",
"wordWrap.bounded": "當檢視區縮至最小並設定 '#editor.wordWrapColumn#' 時換行。",
@ -435,7 +494,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"wrappingIndent.indent": "換行的縮排為父行 +1。",
"wrappingIndent.none": "無縮排。換行從第 1 列開始。",
"wrappingIndent.same": "換行的縮排會與父行相同。",
"wrappingStrategy": "控制計算外圍點的演算法。",
"wrappingStrategy": "控制計算外圍點的演算法。請注意，在協助工具模式中，會使用進階來獲得最佳體驗。",
"wrappingStrategy.advanced": "將外圍點計算委派給瀏覽器。這是緩慢的演算法，如果檔案較大可能會導致凍結，但在所有情況下都正常運作。",
"wrappingStrategy.simple": "假設所有字元的寬度均相同。這是一種快速的演算法，適用於等寬字型，以及字符寬度相同的部分指令碼 (例如拉丁文字元)。"
},
@ -467,13 +526,14 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorBracketPairGuide.background6": "非使用中括弧配對輔助線 (6) 的背景色彩。需要啟用括弧配對輔助線。",
"editorCodeLensForeground": "編輯器程式碼濾鏡的前景色彩",
"editorCursorBackground": "編輯器游標的背景色彩。允許自訂區塊游標重疊的字元色彩。",
"editorDimmedLineNumber": "editor.renderFinalNewline 設定為暗灰色時，最終編輯器線條的色彩。",
"editorGhostTextBackground": "編輯器中浮水印文字的背景色彩。",
"editorGhostTextBorder": "編輯器中浮水印文字的邊框色彩。",
"editorGhostTextForeground": "編輯器中浮水印文字的前景色彩。",
"editorGutter": "編輯器邊框的背景顏色,包含行號與字形圖示的邊框.",
"editorIndentGuides": "編輯器縮排輔助線的色彩。",
"editorLineNumbers": "編輯器行號的色彩。",
"editorOverviewRulerBackground": "編輯器概觀尺規的背景色彩。僅在啟用縮圖並將其置於編輯器右側時使用。",
"editorOverviewRulerBackground": "編輯器概觀尺規的背景色彩。",
"editorOverviewRulerBorder": "預覽檢視編輯器尺規的邊框色彩.",
"editorRuler": "編輯器尺規的色彩",
"editorUnicodeHighlight.background": "用來醒目提示 Unicode 字元的背景色彩。",
@ -566,6 +626,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tabFocusModeOnMsgNoKb": "在目前的編輯器中按 Tab 鍵會將焦點移至下一個可設定焦點的元素。命令 {0} 目前無法由按鍵繫結關係觸發。",
"toggleHighContrast": "切換高對比佈景主題"
},
"vs/editor/common/viewLayout/viewLineRenderer": {
"overflow.chars": "{0} chars",
"showMore": "顯示更多 ({0})"
},
"vs/editor/contrib/anchorSelect/browser/anchorSelect": {
"anchorSet": "設定錨點為 {0}:{1}",
"cancelSelectionAnchor": "取消選取範圍錨點",
@ -595,10 +659,13 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"copy as": "複製為",
"miCopy": "複製(&&C)",
"miCut": "剪下(&&T)",
"miPaste": "貼上(&&P)"
"miPaste": "貼上(&&P)",
"share": "共用"
},
"vs/editor/contrib/codeAction/browser/codeAction": {
"applyCodeActionFailed": "套用程式碼動作時發生未知的錯誤"
},
"vs/editor/contrib/codeAction/browser/codeActionCommands": {
"applyCodeActionFailed": "套用程式碼動作時發生未知的錯誤",
"args.schema.apply": "控制要套用傳回動作的時機。",
"args.schema.apply.first": "一律套用第一個傳回的程式碼動作。",
"args.schema.apply.ifSingle": "如果傳回的程式碼動作是唯一動作，則加以套用。",
@ -626,8 +693,26 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"organizeImports.label": "組織匯入",
"quickfix.trigger.label": "快速修復...",
"refactor.label": "重構...",
"refactor.preview.label": "使用預覽重構...",
"source.label": "來源動作..."
},
"vs/editor/contrib/codeAction/browser/codeActionContributions": {
"showCodeActionHeaders": "啟用/停用在 [程式碼動作] 功能表中顯示群組標頭。"
},
"vs/editor/contrib/codeAction/browser/codeActionMenu": {
"codeAction.widget.id.convert": "重寫...",
"codeAction.widget.id.extract": "擷取...",
"codeAction.widget.id.inline": "內嵌...",
"codeAction.widget.id.more": "更多動作...",
"codeAction.widget.id.move": "移動...",
"codeAction.widget.id.quickfix": "快速修正...",
"codeAction.widget.id.source": "來源動作...",
"codeAction.widget.id.surround": "範圍陳述式..."
},
"vs/editor/contrib/codeAction/browser/codeActionUi": {
"hideMoreActions": "隱藏已停用項目",
"showMoreActions": "顯示已停用項目"
},
"vs/editor/contrib/codeAction/browser/lightBulbWidget": {
"codeAction": "顯示程式碼動作",
"codeActionWithKb": "顯示程式碼動作 ({0})",
@ -648,12 +733,30 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"miToggleLineComment": "切換行註解(&&T)"
},
"vs/editor/contrib/contextmenu/browser/contextmenu": {
"action.showContextMenu.label": "顯示編輯器內容功能表"
"action.showContextMenu.label": "顯示編輯器內容功能表",
"context.minimap.minimap": "縮圖",
"context.minimap.renderCharacters": "轉譯字元",
"context.minimap.size": "垂直大小",
"context.minimap.size.fill": "填滿",
"context.minimap.size.fit": "最適大小",
"context.minimap.size.proportional": "按比例",
"context.minimap.slider": "滑桿",
"context.minimap.slider.always": "一律",
"context.minimap.slider.mouseover": "滑鼠移至上方"
},
"vs/editor/contrib/copyPaste/browser/copyPasteContribution": {
"pasteActions": "在貼上時啟用/停用從延伸模組執行編輯。"
},
"vs/editor/contrib/copyPaste/browser/copyPasteController": {
"pasteProgressTitle": "正在執行貼上處理常式..."
},
"vs/editor/contrib/cursorUndo/browser/cursorUndo": {
"cursor.redo": "游標重做",
"cursor.undo": "游標復原"
},
"vs/editor/contrib/dropIntoEditor/browser/dropIntoEditorContribution": {
"dropProgressTitle": "正在執行置放處理常式..."
},
"vs/editor/contrib/editorState/browser/keybindingCancellation": {
"cancellableOperation": "編輯器是否執行可取消的作業，例如「預覽參考」"
},
@ -662,6 +765,9 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"actions.find.matchCaseOverride": "覆寫 \"Math Case\" 旗標。\r\n日後將不會儲存此旗標。\r\n0: 不執行任何動作\r\n1: True\r\n2: False",
"actions.find.preserveCaseOverride": "覆寫 \"Preserve Case\" 旗標。\r\n日後將不會儲存此旗標。\r\n0: 不執行任何動作\r\n1: True\r\n2: False",
"actions.find.wholeWordOverride": "覆寫 \"Match Whole Word\" 旗標。\r\n日後將不會儲存此旗標。\r\n0: 不執行任何動作\r\n1: True\r\n2: False",
"findMatchAction.goToMatch": "移至相符項目...",
"findMatchAction.inputPlaceHolder": "輸入數字以前往特定相符項目 (介於 1 到 {0})",
"findMatchAction.inputValidationMessage": "請輸入介於 1 和 {0} 之間的數字。",
"findNextMatchAction": "尋找下一個",
"findPreviousMatchAction": "尋找上一個",
"miFind": "尋找(&&F)",
@ -702,19 +808,18 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"title.matchesCountLimit": "僅反白顯示前 {0} 筆結果，但所有尋找作業會在完整文字上執行。"
},
"vs/editor/contrib/folding/browser/folding": {
"editorGutter.foldingControlForeground": "編輯器裝訂邊的摺疊控制項色彩。",
"createManualFoldRange.label": "從選取範圍建立摺疊範圍",
"foldAction.label": "摺疊",
"foldAllAction.label": "全部摺疊",
"foldAllBlockComments.label": "摺疊全部區塊註解",
"foldAllExcept.label": "折疊所選區域以外的所有區域",
"foldAllMarkerRegions.label": "摺疊所有區域",
"foldBackgroundBackground": "已摺疊範圍後的背景色彩。色彩不得處於不透明狀態，以免隱藏底層裝飾。",
"foldLevelAction.label": "摺疊層級 {0}",
"foldRecursivelyAction.label": "以遞迴方式摺疊",
"gotoNextFold.label": "移至下一個摺疊範圍",
"gotoParentFold.label": "移至父代摺疊",
"gotoPreviousFold.label": "移至上一個摺疊範圍",
"maximum fold ranges": "可摺疊區域的數目限制為上限 {0}。增加設定選項 ['Folding Maximum Regions'](command:workbench.action.openSettings?[\"editor.foldingMaximumRegions\"]) 以啟用更多數目。",
"removeManualFoldingRanges.label": "移除手動折疊範圍",
"toggleFoldAction.label": "切換摺疊",
"unFoldRecursivelyAction.label": "以遞迴方式展開",
"unfoldAction.label": "展開",
@ -723,8 +828,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"unfoldAllMarkerRegions.label": "展開所有區域"
},
"vs/editor/contrib/folding/browser/foldingDecorations": {
"editorGutter.foldingControlForeground": "編輯器裝訂邊的摺疊控制項色彩。",
"foldBackgroundBackground": "已摺疊範圍後的背景色彩。色彩不得處於不透明狀態，以免隱藏底層裝飾。",
"foldingCollapsedIcon": "編輯器字符邊界中 [摺疊的範圍] 的圖示。",
"foldingExpandedIcon": "編輯器字符邊界中 [展開的範圍] 的圖示。"
"foldingExpandedIcon": "編輯器字符邊界中 [展開的範圍] 的圖示。",
"foldingManualCollapedIcon": "編輯器字符邊界中手動摺疊範圍的圖示。",
"foldingManualExpandedIcon": "編輯器字符邊界中手動展開範圍的圖示。"
},
"vs/editor/contrib/fontZoom/browser/fontZoom": {
"EditorFontZoomIn.label": "編輯器字體放大",
@ -843,6 +952,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/hover/browser/markdownHoverParticipant": {
"modesContentHover.loading": "正在載入...",
"stopped rendering": "由於效能原因，已暫停轉譯。這可透過 `editor.stopRenderingLineAfter` 進行設定。",
"too many characters": "因效能的緣故，已跳過將長的行 Token 化。您可透過 `editor.maxTokenizationLineLength` 設定。"
},
"vs/editor/contrib/hover/browser/markerHoverParticipant": {
@ -852,7 +962,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"view problem": "檢視問題"
},
"vs/editor/contrib/indentation/browser/indentation": {
"changeTabDisplaySize": "變更索引標籤顯示大小",
"configuredTabSize": "已設定的定位點大小",
"currentTabSize": "目前的索引標籤大小",
"defaultTabSize": "預設索引標籤大小",
"detectIndentation": "偵測內容中的縮排",
"editor.reindentlines": "重新將行縮排",
"editor.reindentselectedlines": "重新將選取的行縮排",
@ -873,12 +986,32 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"links.navigate.kb.meta.mac": "cmd + 按一下"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextController": {
"accept": "接受",
"acceptWord": "接受字組",
"action.inlineSuggest.accept": "接受內嵌建議",
"action.inlineSuggest.acceptNextWord": "接受下一個內嵌建議字組",
"action.inlineSuggest.alwaysShowToolbar": "永遠顯示工具列",
"action.inlineSuggest.hide": "隱藏內嵌建議",
"action.inlineSuggest.showNext": "顯示下一個內嵌建議",
"action.inlineSuggest.showPrevious": "顯示上一個內嵌建議",
"action.inlineSuggest.trigger": "觸發內嵌建議",
"action.inlineSuggest.undo": "復原接受字組",
"alwaysShowInlineSuggestionToolbar": "是否一律顯示內嵌建議工具列",
"canUndoInlineSuggestion": "復原是否復原內嵌建議",
"inlineSuggestionHasIndentation": "內嵌建議是否以空白字元開頭",
"inlineSuggestionHasIndentationLessThanTabSize": "內嵌建議的開頭是否為空白，且比 Tab 能插入的字元要小",
"inlineSuggestionVisible": "是否顯示內嵌建議"
"inlineSuggestionVisible": "是否顯示內嵌建議",
"undoAcceptWord": "復原接受字組"
},
"vs/editor/contrib/inlineCompletions/browser/ghostTextHoverParticipant": {
"inlineSuggestionFollows": "建議:"
},
"vs/editor/contrib/inlineCompletions/browser/inlineSuggestionHintsWidget": {
"content": "{0} ({1})",
"next": "下一步",
"parameterHintsNextIcon": "[顯示下一個參數提示] 的圖示。",
"parameterHintsPreviousIcon": "[顯示上一個參數提示] 的圖示。",
"previous": "上一步"
},
"vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace": {
"InPlaceReplaceAction.next.label": "以下一個值取代",
@ -889,6 +1022,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/linesOperations/browser/linesOperations": {
"duplicateSelection": "重複選取項目",
"editor.transformToCamelcase": "轉換為 Camel 案例",
"editor.transformToKebabcase": "轉換成 Kebab Case",
"editor.transformToLowercase": "轉換到小寫",
"editor.transformToSnakecase": "轉換為底線連接字",
"editor.transformToTitlecase": "轉換為字首大寫",
@ -933,7 +1068,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"tooltip.explanation": "執行命令 {0}"
},
"vs/editor/contrib/message/browser/messageController": {
"editor.readonly": "無法在唯讀編輯器中編輯",
"messageVisible": "編輯器目前是否正在顯示內嵌訊息"
},
"vs/editor/contrib/multicursor/browser/multicursor": {
@ -952,6 +1086,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"moveSelectionToPreviousFindMatch": "將最後一個選擇項目移至前一個找到的相符項",
"mutlicursor.addCursorsToBottom": "將游標新增到底部 ",
"mutlicursor.addCursorsToTop": "將游標新增到頂部",
"mutlicursor.focusNextCursor": "聚焦下一個游標",
"mutlicursor.focusNextCursor.description": "聚焦下一個游標",
"mutlicursor.focusPreviousCursor": "聚焦上一個游標",
"mutlicursor.focusPreviousCursor.description": "聚焦前一個游標",
"mutlicursor.insertAbove": "在上方加入游標",
"mutlicursor.insertAtEndOfEachLineSelected": "在行尾新增游標",
"mutlicursor.insertBelow": "在下方加入游標",
@ -974,6 +1112,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"peekViewEditorGutterBackground": "預覽檢視編輯器邊框(含行號或字形圖示)的背景色彩。",
"peekViewEditorMatchHighlight": "預覽檢視編輯器中比對時的反白顯示色彩。",
"peekViewEditorMatchHighlightBorder": "在預覽檢視編輯器中比對時的反白顯示邊界。",
"peekViewEditorStickScrollBackground": "預覽檢視編輯器中黏性滾動的背景色彩。",
"peekViewResultsBackground": "預覽檢視中結果清單的背景色彩。",
"peekViewResultsFileForeground": "預覽檢視結果列表中檔案節點的前景色彩",
"peekViewResultsMatchForeground": "預覽檢視結果列表中行節點的前景色彩",
@ -1025,12 +1164,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"typeParameter": "型別參數 ({0})",
"variable": "變數 ({0})"
},
"vs/editor/contrib/readOnlyMessage/browser/contribution": {
"editor.readonly": "無法在唯讀編輯器中編輯",
"editor.simple.readonly": "無法在唯讀輸入中編輯"
},
"vs/editor/contrib/rename/browser/rename": {
"aria": "已成功將 '{0}' 重新命名為 '{1}'。摘要: {2}",
"enablePreview": "啟用/停用重新命名前先預覽變更的功能",
"label": "正在為 '{0}' 重新命名",
"label": "正在將 '{0}' 重新命名為 '{1}'",
"no result": "沒有結果。",
"quotableLabel": "正在重新命名 {0}",
"quotableLabel": "正在將 {0} 重新命名為 {1}",
"rename.failed": "重新命名無法計算編輯",
"rename.failedApply": "重命名無法套用編輯",
"rename.label": "重新命名符號",
@ -1038,7 +1181,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/rename/browser/renameInputField": {
"label": "按 {0} 進行重新命名，按 {1} 進行預覽",
"renameAriaLabel": "為輸入重新命名。請鍵入新名稱，然後按 Enter 以認可。",
"renameAriaLabel": "為輸入重新命名。請鍵入新名稱，然後按 Enter 以提交。",
"renameInputVisible": "是否顯示重新命名輸入小工具"
},
"vs/editor/contrib/smartSelect/browser/smartSelect": {
@ -1050,7 +1193,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/editor/contrib/snippet/browser/snippetController2": {
"hasNextTabstop": "在程式碼片段模式中是否有下一個定位停駐點",
"hasPrevTabstop": "在程式碼片段模式中是否有上一個定位停駐點",
"inSnippetMode": "編輯器目前是否在程式碼片段模式中"
"inSnippetMode": "編輯器目前是否在程式碼片段模式中",
"next": "移至下一個預留位置..."
},
"vs/editor/contrib/snippet/browser/snippetVariables": {
"April": "四月",
@ -1092,9 +1236,16 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"Wednesday": "星期三",
"WednesdayShort": "週三"
},
"vs/editor/contrib/stickyScroll/browser/stickyScrollActions": {
"miStickyScroll": "自黏捲動(&&S)",
"mitoggleStickyScroll": "切換自黏捲動(&&T)",
"stickyScroll": "自黏捲動",
"toggleStickyScroll": "切換自黏捲動"
},
"vs/editor/contrib/suggest/browser/suggest": {
"acceptSuggestionOnEnter": "是否在按下 Enter 時插入建議",
"suggestWidgetDetailsVisible": "是否顯示建議詳細資料",
"suggestWidgetHasSelection": "是否聚焦任何建議",
"suggestWidgetMultipleSuggestions": "是否有多個建議可以挑選",
"suggestionCanResolve": "目前的建議是否支援解決更多詳細資料",
"suggestionHasInsertAndReplaceRange": "目前的建議是否有插入和取代行為",
@ -1137,7 +1288,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"suggestMoreInfoIcon": "建議小工具中 [更多詳細資訊] 的圖示。"
},
"vs/editor/contrib/suggest/browser/suggestWidgetStatus": {
"ddd": "{0} ({1})"
"content": "{0} ({1})"
},
"vs/editor/contrib/symbolIcons/browser/symbolIcons": {
"symbolIcon.arrayForeground": "陣列符號的前景色彩。這些符號會出現在大綱、階層連結和建議小工具中。",
@ -1209,29 +1360,83 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
},
"vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators": {
"unusualLineTerminators.detail": "檔案 '{0}' 包含一或多個異常的行結束字元，例如行分隔符號 (LS) 或段落分隔符號 (PS)。\r\n\r\n建議您將其從檔案中移除。這可以透過 `editor.unusualLineTerminators` 進行設定。",
"unusualLineTerminators.fix": "移除異常的行結束字元",
"unusualLineTerminators.fix": "移除異常的行結束字元(&&R)",
"unusualLineTerminators.ignore": "忽略",
"unusualLineTerminators.message": "偵測到異常的行結束字元",
"unusualLineTerminators.title": "異常的行結束字元"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"vs/editor/contrib/wordHighlighter/browser/highlightDecorations": {
"overviewRulerWordHighlightForeground": "符號醒目提示的概觀尺規標記色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"overviewRulerWordHighlightStrongForeground": "寫入權限符號醒目提示的概觀尺規標記色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"overviewRulerWordHighlightTextForeground": "符號文字出現的概觀尺規標記色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"wordHighlight": "讀取權限期間 (如讀取變數) 符號的背景色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"wordHighlight.next.label": "移至下一個反白符號",
"wordHighlight.previous.label": "移至上一個反白符號",
"wordHighlight.trigger.label": "觸發符號反白顯示",
"wordHighlightBorder": "讀取存取期間 (例如讀取變數時) 符號的邊框顏色。",
"wordHighlightStrong": "寫入權限期間 (如寫入變數) 符號的背景色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"wordHighlightStrongBorder": "寫入存取期間 (例如寫入變數時) 符號的邊框顏色。 "
"wordHighlightStrongBorder": "寫入存取期間 (例如寫入變數時) 符號的邊框顏色。 ",
"wordHighlightText": "符號文字出現的背景色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"wordHighlightTextBorder": "符號文字出現的框線色彩。"
},
"vs/editor/contrib/wordHighlighter/browser/wordHighlighter": {
"wordHighlight.next.label": "移至下一個反白符號",
"wordHighlight.previous.label": "移至上一個反白符號",
"wordHighlight.trigger.label": "觸發符號反白顯示"
},
"vs/editor/contrib/wordOperations/browser/wordOperations": {
"deleteInsideWord": "刪除字組"
},
"vs/platform/action/common/actionCommonCategories": {
"developer": "開發人員",
"help": "說明",
"preferences": "喜好設定",
"test": "測試",
"view": "檢視"
},
"vs/platform/actions/browser/menuEntryActionViewItem": {
"titleAndKb": "{0} ({1})"
"titleAndKb": "{0} ({1})",
"titleAndKbAndAlt": "{0}\r\n[{1}] {2}"
},
"vs/platform/actions/browser/toolbar": {
"hide": "隱藏",
"resetThisMenu": "重設功能表"
},
"vs/platform/actions/common/menuService": {
"hide.label": "隱藏 '{0}'"
},
"vs/platform/actionWidget/browser/actionList": {
"customQuickFixWidget": "動作小工具",
"customQuickFixWidget.labels": "{0}，停用原因: {1}",
"label": "{0} 以申請",
"label-preview": "{0} 以套用，{1} 以預覽"
},
"vs/platform/actionWidget/browser/actionWidget": {
"acceptSelected.title": "接受選取的動作",
"codeActionMenuVisible": "是否顯示動作小工具清單",
"hideCodeActionWidget.title": "隱藏動作小工具",
"previewSelected.title": "預覽選取的動作",
"selectNextCodeAction.title": "選取下一個動作",
"selectPrevCodeAction.title": "選取上一個動作"
},
"vs/platform/audioCues/browser/audioCueService": {
"audioCues.diffLineDeleted": "差異行已刪除",
"audioCues.diffLineInserted": "差異行已插入",
"audioCues.diffLineModified": "差異行已修改",
"audioCues.lineHasBreakpoint.name": "行上的中斷點",
"audioCues.lineHasError.name": "行上發生錯誤",
"audioCues.lineHasFoldedArea.name": "行上的摺疊區域",
"audioCues.lineHasInlineSuggestion.name": "行上的內嵌建議",
"audioCues.lineHasWarning.name": "行上的警告",
"audioCues.noInlayHints": "行上沒有嵌入提示",
"audioCues.notebookCellCompleted": "Notebook 儲存格已完成",
"audioCues.notebookCellFailed": "Notebook 儲存格失敗",
"audioCues.onDebugBreak.name": "在中斷點停止偵錯工具",
"audioCues.taskCompleted": "工作完成",
"audioCues.taskFailed": "工作失敗",
"audioCues.terminalBell": "終端鈴",
"audioCues.terminalCommandFailed": "終端機命令失敗",
"audioCues.terminalQuickFix.name": "終端機快速修正"
},
"vs/platform/configuration/common/configurationRegistry": {
"config.policy.duplicate": "無法註冊 '{0}'。已向 {2} 註冊關聯的原則 {1}。",
"config.property.duplicate": "無法註冊 '{0}'。此屬性已經註冊。",
"config.property.empty": "無法註冊空白屬性",
"config.property.languageDefault": "無法註冊 '{0}'。這符合用於描述語言專用編輯器設定的屬性模式 '\\\\[.*\\\\]$'。請使用 'configurationDefaults' 貢獻。",
@ -1249,12 +1454,20 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"isLinux": "作業系統是否為 Linux",
"isMac": "作業系統是否為 macOS",
"isMacNative": "非瀏覽器平台上的作業系統是否為 macOS",
"isMobile": "平臺是否為行動網頁瀏覽器",
"isWeb": "平台是否為網頁瀏覽器",
"isWindows": "作業系統是否為 Windows"
"isWindows": "作業系統是否為 Windows",
"productQualityType": "VS Code 的品質類型"
},
"vs/platform/dialogs/common/dialogs": {
"cancelButton": "取消",
"moreFile": "...另外 1 個檔案未顯示",
"moreFiles": "...另外 {0} 個檔案未顯示"
"moreFiles": "...另外 {0} 個檔案未顯示",
"okButton": "確定(&&O)",
"yesButton": "是(&&Y)"
},
"vs/platform/dnd/browser/dnd": {
"fileTooLarge": "檔案過大，無法以未命名的編輯器開啟。請先將其上傳至檔案總管，並再試一次。"
},
"vs/platform/files/common/files": {
"sizeB": "{0}B",
@ -1274,20 +1487,28 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"vs/platform/list/browser/listService": {
"Fast Scroll Sensitivity": "按下 `Alt` 時的捲動速度乘數。",
"Mouse Wheel Scroll Sensitivity": "要用於滑鼠滾輪捲動事件 `deltaX` 和 `deltaY` 的乘數。",
"automatic keyboard navigation setting": "控制是否只要鍵入即可自動觸發清單和樹狀結構中的鍵盤瀏覽。若設為 `false`，只有在執行 `list.toggleKeyboardNavigation` 命令時，才會觸發鍵盤瀏覽，您可為其指定鍵盤快速鍵。",
"defaultFindMatchTypeSettingKey": "控制在工作台中搜尋清單和樹狀結構時所使用的比對類型。",
"defaultFindMatchTypeSettingKey.contiguous": "搜尋時使用連續比對。",
"defaultFindMatchTypeSettingKey.fuzzy": "搜尋時使用模糊比對。",
"defaultFindModeSettingKey": "控制 Workbench 中清單和樹狀結構的預設尋找模式。",
"defaultFindModeSettingKey.filter": "搜尋時篩選元素。",
"defaultFindModeSettingKey.highlight": "搜尋時會醒目提示元素。進一步的向上和向下瀏覽只會周遊已醒目提示的元素。",
"expand mode": "控制當按下資料夾名稱時，樹狀目錄資料夾的展開方式。請注意，若不適用，某些樹狀目錄和清單可能會選擇忽略此設定。",
"horizontalScrolling setting": "控制在工作台中，清單與樹狀結構是否支援水平捲動。警告: 開啟此設定將會影響效能。",
"keyboardNavigationSettingKey": "控制 Workbench 中清單和樹狀結構的鍵盤瀏覽樣式。可以是簡易的、醒目提示和篩選。",
"keyboardNavigationSettingKey.filter": "篩選鍵盤瀏覽會篩掉並隱藏不符合鍵盤輸入的所有元素。",
"keyboardNavigationSettingKey.highlight": "醒目提示鍵盤瀏覽會醒目提示符合鍵盤輸入的元素。進一步向上或向下瀏覽只會周遊醒目提示的元素。",
"keyboardNavigationSettingKey.simple": "比對按鍵輸入的簡易按鍵瀏覽焦點元素。僅比對前置詞。",
"keyboardNavigationSettingKeyDeprecated": "請改為使用 'workbench.list.defaultFindMode' 和 'workbench.list.typeNavigationMode'。",
"list smoothScrolling setting": "控制清單和樹狀結構是否具有平滑捲動。",
"list.scrollByPage": "控制按一下捲軸是否逐頁捲動。",
"multiSelectModifier": "透過滑鼠多選，用於在樹狀目錄與清單中新增項目的輔助按鍵 (例如在總管中開啟編輯器 及 SCM 檢視)。'在側邊開啟' 滑鼠手勢 (若支援) 將會適應以避免和多選輔助按鍵衝突。",
"multiSelectModifier.alt": "對應Windows和Linux的'Alt'與對應macOS的'Option'。",
"multiSelectModifier.ctrlCmd": "對應Windows和Linux的'Control'與對應 macOS 的'Command'。",
"openModeModifier": "控制如何使用滑鼠 (如支援此用法) 開啟樹狀目錄與清單中的項目。若不適用，某些樹狀目錄與清單可能會選擇忽略此設定。",
"render tree indent guides": "控制樹系是否應轉譯縮排輔助線。",
"tree indent setting": "控制樹狀結構縮排 (像素)。",
"typeNavigationMode": "控制工作台中清單和樹狀目錄的類型瀏覽運作方式。設定為 'trigger' 時，類型瀏覽會在執行 'list.triggerTypeNavigation' 命令時隨即開始。",
"workbenchConfigurationTitle": "工作台"
},
"vs/platform/markers/common/markers": {
@ -1296,16 +1517,34 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"sev.warning": "警告"
},
"vs/platform/quickinput/browser/commandsQuickAccess": {
"canNotRun": "命令 '{0}' 造成錯誤 ({1})",
"canNotRun": "命令 '{0}' 造成錯誤",
"commandPickAriaLabelWithKeybinding": "{0}, {1}",
"commonlyUsed": "經常使用",
"morecCommands": "其他命令",
"recentlyUsed": "最近使用的"
},
"vs/platform/quickinput/browser/helpQuickAccess": {
"editorCommands": "編輯器命令",
"globalCommands": "全域命令",
"helpPickAriaLabel": "{0}, {1}"
},
"vs/platform/quickinput/browser/quickInput": {
"custom": "自訂",
"inputModeEntry": "按 'Enter' 鍵確認您的輸入或按 'Esc' 鍵取消",
"inputModeEntryDescription": "{0} (按 'Enter' 鍵確認或按 'Esc' 鍵取消)",
"ok": "確定",
"quickInput.back": "上一頁",
"quickInput.backWithKeybinding": "背面 ({0})",
"quickInput.checkAll": "切換所有核取方塊",
"quickInput.countSelected": "已選擇 {0}",
"quickInput.steps": "{0}/{1}",
"quickInput.visibleCount": "{0} 個結果",
"quickInputBox.ariaLabel": "輸入以縮小結果範圍。"
},
"vs/platform/quickinput/browser/quickInputList": {
"quickInput": "快速輸入"
},
"vs/platform/quickinput/browser/quickInputUtils": {
"executeCommand": "按一下以執行命令 ‘{0}’"
},
"vs/platform/theme/common/colorRegistry": {
"activeContrastBorder": "使用中項目周圍的額外邊界，可將項目從其他項目中區隔出來以提高對比。",
"activeLinkForeground": "使用中之連結的色彩。",
@ -1314,7 +1553,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"breadcrumbsBackground": "階層連結的背景色。",
"breadcrumbsFocusForeground": "焦點階層連結項目的色彩。",
"breadcrumbsSelectedBackground": "階層連結項目選擇器的背景色彩。",
"breadcrumbsSelectedForegound": "所選階層連結項目的色彩。",
"breadcrumbsSelectedForeground": "所選階層連結項目的色彩。",
"buttonBackground": "按鈕背景色彩。",
"buttonBorder": "按鈕框線色彩。",
"buttonForeground": "按鈕前景色彩。",
@ -1322,6 +1561,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"buttonSecondaryBackground": "次要按鈕背景色彩。",
"buttonSecondaryForeground": "次要按鈕前景色彩。",
"buttonSecondaryHoverBackground": "滑鼠暫留時的次要按鈕背景色彩。",
"buttonSeparator": "分隔線色彩按鈕。",
"chartsBlue": "圖表視覺效果中所使用的藍色。",
"chartsForeground": "圖表中使用的前景色彩。",
"chartsGreen": "圖表視覺效果中所使用的綠色。",
@ -1333,6 +1573,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"checkbox.background": "核取方塊小工具的背景色彩。",
"checkbox.border": "核取方塊小工具的框線色彩。",
"checkbox.foreground": "核取方塊小工具的前景色彩。",
"checkbox.select.background": "選取其所處元素時，核取方塊小工具的背景色彩。",
"checkbox.select.border": "選取其所處元素時，核取方塊小工具的框線色彩。",
"contrastBorder": "項目周圍的額外框線，可將項目從其他項目中區隔出來以提高對比。",
"descriptionForeground": "提供附加訊息的前景顏色,例如標籤",
"diffDiagonalFill": "Diff 編輯器的斜紋填滿色彩。斜紋填滿用於並排 Diff 檢視。",
@ -1347,6 +1589,7 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"diffEditorRemovedLineGutter": "移除程式行所在邊界的背景色彩。",
"diffEditorRemovedLines": "已移除程式行的背景色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"diffEditorRemovedOutline": "移除的文字外框色彩。",
"disabledForeground": "已停用元素的整體前景。只有在元件未覆蓋時，才能使用這個色彩。",
"dropdownBackground": "下拉式清單的背景。",
"dropdownBorder": "下拉式清單的框線。",
"dropdownForeground": "下拉式清單的前景。",
@ -1373,6 +1616,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"editorSelectionForeground": "為選取的文字顏色高對比化",
"editorSelectionHighlight": "與選取項目內容相同之區域的色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"editorSelectionHighlightBorder": "選取時，內容相同之區域的框線色彩。",
"editorStickyScrollBackground": "編輯器的黏滯卷軸背景色彩",
"editorStickyScrollHoverBackground": "編輯器的游標背景色彩上的黏滯卷軸",
"editorWarning.background": "編輯器中警告文字的背景色彩。其不得為不透明色彩，以免隱藏底層裝飾。",
"editorWarning.foreground": "編輯器內警告提示線的前景色彩.",
"editorWidgetBackground": "編輯器小工具的背景色彩，例如尋找/取代。",
@ -1428,6 +1673,8 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"listFilterWidgetBackground": "清單和樹狀結構中類型篩選小工具的背景色彩。",
"listFilterWidgetNoMatchesOutline": "在沒有相符項目時，清單和樹狀結構中類型篩選小工具的大綱色彩。",
"listFilterWidgetOutline": "清單和樹狀結構中類型篩選小工具的大綱色彩。",
"listFilterWidgetShadow": "清單和樹狀結構中類型篩選小工具的陰影色彩。",
"listFocusAndSelectionOutline": "當清單/樹狀目錄為使用中狀態並已選取時，焦點項目的清單/樹狀目錄外框色彩。使用中的清單/樹狀目錄具有鍵盤焦點，非使用中者則沒有。",
"listFocusBackground": "當清單/樹狀為使用中狀態時，焦點項目的清單/樹狀背景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。",
"listFocusForeground": "當清單/樹狀為使用中狀態時，焦點項目的清單/樹狀前景色彩。使用中的清單/樹狀有鍵盤焦點，非使用中者則沒有。",
"listFocusHighlightForeground": "在清單/樹狀內搜尋時，相符項目的清單/樹狀結構前景色彩會針對主動焦點項目進行強調顯示。",
@ -1507,8 +1754,10 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"toolbarActiveBackground": "將滑鼠移到動作上方時的工具列背景",
"toolbarHoverBackground": "使用滑鼠將游標停留在動作上方時的工具列背景",
"toolbarHoverOutline": "使用滑鼠將游標停留在動作上方時的工具列外框",
"treeInactiveIndentGuidesStroke": "非使用中縮排輔助線的樹狀筆觸色彩。",
"treeIndentGuidesStroke": "縮排輔助線的樹狀筆觸色彩。",
"warningBorder": "編輯器中的警告方塊框線色彩。",
"widgetBorder": "小工具的框線色彩，例如編輯器中的尋找/取代。",
"widgetShadow": "小工具的陰影色彩，例如編輯器中的尋找/取代。"
},
"vs/platform/theme/common/iconRegistry": {
@ -1519,7 +1768,6 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"widgetClose": "小工具中關閉動作的圖示。"
},
"vs/platform/undoRedo/common/undoRedoService": {
"cancel": "取消",
"cannotResourceRedoDueToInProgressUndoRedo": "因為已經有正在執行的復原或重做作業，所以無法重做 '{0}'。",
"cannotResourceUndoDueToInProgressUndoRedo": "因為已經有正在執行的復原或重做作業，所以無法復原 '{0}'。",
"cannotWorkspaceRedo": "無法復原所有檔案的 '{0}'。{1}",
@ -1532,12 +1780,12 @@ window.MonacoEnvironment.Locale = window.MonacoLocale = {
"cannotWorkspaceUndoDueToInProgressUndoRedo": "因為 {1} 中已經有正在執行的復原或重做作業，所以無法為所有檔案復原 '{0}'",
"confirmDifferentSource": "要復原 '{0}' 嗎?",
"confirmDifferentSource.no": "否",
"confirmDifferentSource.yes": "是",
"confirmDifferentSource.yes": "是(&&Y)",
"confirmWorkspace": "要復原所有檔案的 '{0}' 嗎?",
"externalRemoval": "已在磁碟上關閉並修改以下檔案: {0}。",
"noParallelUniverses": "下列檔案已使用不相容的方式修改: {0}。",
"nok": "復原此檔案",
"ok": "在 {0} 個檔案中復原"
"nok": "復原此檔案(&&F)",
"ok": "在 {0} 個檔案中復原(&&U)"
},
"vs/platform/workspace/common/workspace": {
"codeWorkspace": "Code 工作區"

236
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/theme/forge.json vendored Normal file
View File

@ -0,0 +1,236 @@
{
"base": "vs",
"inherit": true,
"rules": [
{
"background": "FFFFFF",
"token": ""
},
{
"foreground": "8e908c",
"token": "comment"
},
{
"foreground": "31959A",
"token": "keyword.operator.class"
},
{
"foreground": "31959A",
"token": "constant.other"
},
{
"foreground": "c82829",
"token": "variable"
},
{
"foreground": "c82829",
"token": "support.other.variable"
},
{
"foreground": "c82829",
"token": "string.other.link"
},
{
"foreground": "c82829",
"token": "string.regexp"
},
{
"foreground": "c82829",
"token": "entity.name.tag"
},
{
"foreground": "c82829",
"token": "entity.other.attribute-name"
},
{
"foreground": "c82829",
"token": "meta.tag"
},
{
"foreground": "c82829",
"token": "declaration.tag"
},
{
"foreground": "c82829",
"token": "markup.deleted.git_gutter"
},
{
"foreground": "f5871f",
"token": "constant.numeric"
},
{
"foreground": "f5871f",
"token": "constant.language"
},
{
"foreground": "f5871f",
"token": "support.constant"
},
{
"foreground": "f5871f",
"token": "constant.character"
},
{
"foreground": "f5871f",
"token": "variable.parameter"
},
{
"foreground": "f5871f",
"token": "punctuation.section.embedded"
},
{
"foreground": "f5871f",
"token": "keyword.other.unit"
},
{
"foreground": "c99e00",
"token": "entity.name.class"
},
{
"foreground": "c99e00",
"token": "entity.name.type.class"
},
{
"foreground": "c99e00",
"token": "support.type"
},
{
"foreground": "c99e00",
"token": "support.class"
},
{
"foreground": "ED4E4E",
"token": "string"
},
{
"foreground": "ED4E4E",
"token": "constant.other.symbol"
},
{
"foreground": "ED4E4E",
"token": "entity.other.inherited-class"
},
{
"foreground": "ED4E4E",
"token": "markup.heading"
},
{
"foreground": "718c00",
"token": "markup.inserted.git_gutter"
},
{
"foreground": "31959A",
"token": "keyword.operator"
},
{
"foreground": "31959A",
"token": "constant.other.color"
},
{
"foreground": "4271ae",
"token": "entity.name.function"
},
{
"foreground": "4271ae",
"token": "meta.function-call"
},
{
"foreground": "4271ae",
"token": "support.function"
},
{
"foreground": "4271ae",
"token": "keyword.other.special-method"
},
{
"foreground": "4271ae",
"token": "meta.block-level"
},
{
"foreground": "4271ae",
"token": "markup.changed.git_gutter"
},
{
"foreground": "31959A",
"token": "keyword"
},
{
"foreground": "8959a8",
"token": "storage"
},
{
"foreground": "8959a8",
"token": "storage.type"
},
{
"foreground": "ffffff",
"background": "c82829",
"token": "invalid"
},
{
"foreground": "ffffff",
"background": "4271ae",
"token": "meta.separator"
},
{
"foreground": "ffffff",
"background": "8959a8",
"token": "invalid.deprecated"
},
{
"foreground": "ffffff",
"token": "markup.inserted.diff"
},
{
"foreground": "ffffff",
"token": "markup.deleted.diff"
},
{
"foreground": "ffffff",
"token": "meta.diff.header.to-file"
},
{
"foreground": "ffffff",
"token": "meta.diff.header.from-file"
},
{
"background": "718c00",
"token": "markup.inserted.diff"
},
{
"background": "718c00",
"token": "meta.diff.header.to-file"
},
{
"background": "c82829",
"token": "markup.deleted.diff"
},
{
"background": "c82829",
"token": "meta.diff.header.from-file"
},
{
"foreground": "ffffff",
"background": "4271ae",
"token": "meta.diff.header.from-file"
},
{
"foreground": "ffffff",
"background": "4271ae",
"token": "meta.diff.header.to-file"
},
{
"foreground": "31959A",
"fontStyle": "italic",
"token": "meta.diff.range"
}
],
"colors": {
"editor.foreground": "#4D4D4C",
"editor.background": "#FFFFFF",
"editor.selectionBackground": "#D6D6D6",
"editor.lineHighlightBackground": "#EFEFEF",
"editorCursor.foreground": "#AEAFAD",
"editorWhitespace.foreground": "#D1D1D1"
}
}

348
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/theme/github-dark.json vendored Normal file
View File

@ -0,0 +1,348 @@
{
"base": "vs-dark",
"inherit": true,
"rules": [
{
"background": "24292e",
"token": ""
},
{
"foreground": "959da5",
"token": "comment"
},
{
"foreground": "959da5",
"token": "punctuation.definition.comment"
},
{
"foreground": "959da5",
"token": "string.comment"
},
{
"foreground": "c8e1ff",
"token": "constant"
},
{
"foreground": "c8e1ff",
"token": "entity.name.constant"
},
{
"foreground": "c8e1ff",
"token": "variable.other.constant"
},
{
"foreground": "c8e1ff",
"token": "variable.language"
},
{
"foreground": "b392f0",
"token": "entity"
},
{
"foreground": "b392f0",
"token": "entity.name"
},
{
"foreground": "f6f8fa",
"token": "variable.parameter.function"
},
{
"foreground": "7bcc72",
"token": "entity.name.tag"
},
{
"foreground": "ea4a5a",
"token": "keyword"
},
{
"foreground": "ea4a5a",
"token": "storage"
},
{
"foreground": "ea4a5a",
"token": "storage.type"
},
{
"foreground": "f6f8fa",
"token": "storage.modifier.package"
},
{
"foreground": "f6f8fa",
"token": "storage.modifier.import"
},
{
"foreground": "f6f8fa",
"token": "storage.type.java"
},
{
"foreground": "79b8ff",
"token": "string"
},
{
"foreground": "79b8ff",
"token": "punctuation.definition.string"
},
{
"foreground": "79b8ff",
"token": "string punctuation.section.embedded source"
},
{
"foreground": "c8e1ff",
"token": "support"
},
{
"foreground": "c8e1ff",
"token": "meta.property-name"
},
{
"foreground": "fb8532",
"token": "variable"
},
{
"foreground": "f6f8fa",
"token": "variable.other"
},
{
"foreground": "d73a49",
"fontStyle": "bold italic underline",
"token": "invalid.broken"
},
{
"foreground": "d73a49",
"fontStyle": "bold italic underline",
"token": "invalid.deprecated"
},
{
"foreground": "fafbfc",
"background": "d73a49",
"fontStyle": "italic underline",
"token": "invalid.illegal"
},
{
"foreground": "fafbfc",
"background": "d73a49",
"fontStyle": "italic underline",
"token": "carriage-return"
},
{
"foreground": "d73a49",
"fontStyle": "bold italic underline",
"token": "invalid.unimplemented"
},
{
"foreground": "d73a49",
"token": "message.error"
},
{
"foreground": "f6f8fa",
"token": "string source"
},
{
"foreground": "c8e1ff",
"token": "string variable"
},
{
"foreground": "79b8ff",
"token": "source.regexp"
},
{
"foreground": "79b8ff",
"token": "string.regexp"
},
{
"foreground": "79b8ff",
"token": "string.regexp.character-class"
},
{
"foreground": "79b8ff",
"token": "string.regexp constant.character.escape"
},
{
"foreground": "79b8ff",
"token": "string.regexp source.ruby.embedded"
},
{
"foreground": "79b8ff",
"token": "string.regexp string.regexp.arbitrary-repitition"
},
{
"foreground": "7bcc72",
"fontStyle": "bold",
"token": "string.regexp constant.character.escape"
},
{
"foreground": "c8e1ff",
"token": "support.constant"
},
{
"foreground": "c8e1ff",
"token": "support.variable"
},
{
"foreground": "c8e1ff",
"token": "meta.module-reference"
},
{
"foreground": "fb8532",
"token": "markup.list"
},
{
"foreground": "0366d6",
"fontStyle": "bold",
"token": "markup.heading"
},
{
"foreground": "0366d6",
"fontStyle": "bold",
"token": "markup.heading entity.name"
},
{
"foreground": "c8e1ff",
"token": "markup.quote"
},
{
"foreground": "f6f8fa",
"fontStyle": "italic",
"token": "markup.italic"
},
{
"foreground": "f6f8fa",
"fontStyle": "bold",
"token": "markup.bold"
},
{
"foreground": "c8e1ff",
"token": "markup.raw"
},
{
"foreground": "b31d28",
"background": "ffeef0",
"token": "markup.deleted"
},
{
"foreground": "b31d28",
"background": "ffeef0",
"token": "meta.diff.header.from-file"
},
{
"foreground": "b31d28",
"background": "ffeef0",
"token": "punctuation.definition.deleted"
},
{
"foreground": "176f2c",
"background": "f0fff4",
"token": "markup.inserted"
},
{
"foreground": "176f2c",
"background": "f0fff4",
"token": "meta.diff.header.to-file"
},
{
"foreground": "176f2c",
"background": "f0fff4",
"token": "punctuation.definition.inserted"
},
{
"foreground": "b08800",
"background": "fffdef",
"token": "markup.changed"
},
{
"foreground": "b08800",
"background": "fffdef",
"token": "punctuation.definition.changed"
},
{
"foreground": "2f363d",
"background": "959da5",
"token": "markup.ignored"
},
{
"foreground": "2f363d",
"background": "959da5",
"token": "markup.untracked"
},
{
"foreground": "b392f0",
"fontStyle": "bold",
"token": "meta.diff.range"
},
{
"foreground": "c8e1ff",
"token": "meta.diff.header"
},
{
"foreground": "0366d6",
"fontStyle": "bold",
"token": "meta.separator"
},
{
"foreground": "0366d6",
"token": "meta.output"
},
{
"foreground": "ffeef0",
"token": "brackethighlighter.tag"
},
{
"foreground": "ffeef0",
"token": "brackethighlighter.curly"
},
{
"foreground": "ffeef0",
"token": "brackethighlighter.round"
},
{
"foreground": "ffeef0",
"token": "brackethighlighter.square"
},
{
"foreground": "ffeef0",
"token": "brackethighlighter.angle"
},
{
"foreground": "ffeef0",
"token": "brackethighlighter.quote"
},
{
"foreground": "d73a49",
"token": "brackethighlighter.unmatched"
},
{
"foreground": "d73a49",
"token": "sublimelinter.mark.error"
},
{
"foreground": "fb8532",
"token": "sublimelinter.mark.warning"
},
{
"foreground": "6a737d",
"token": "sublimelinter.gutter-mark"
},
{
"foreground": "79b8ff",
"fontStyle": "underline",
"token": "constant.other.reference.link"
},
{
"foreground": "79b8ff",
"fontStyle": "underline",
"token": "string.other.link"
}
],
"colors": {
"editor.foreground": "#f6f8fa",
"editor.background": "#24292e",
"editor.selectionBackground": "#4c2889",
"editor.inactiveSelectionBackground": "#444d56",
"editor.lineHighlightBackground": "#444d56",
"editorCursor.foreground": "#ffffff",
"editorWhitespace.foreground": "#6a737d",
"editorIndentGuide.background": "#6a737d",
"editorIndentGuide.activeBackground": "#f6f8fa",
"editor.selectionHighlightBorder": "#444d56"
}
}

348
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/theme/github-light.json vendored Normal file
View File

@ -0,0 +1,348 @@
{
"base": "vs",
"inherit": true,
"rules": [
{
"background": "ffffff",
"token": ""
},
{
"foreground": "6a737d",
"token": "comment"
},
{
"foreground": "6a737d",
"token": "punctuation.definition.comment"
},
{
"foreground": "6a737d",
"token": "string.comment"
},
{
"foreground": "005cc5",
"token": "constant"
},
{
"foreground": "005cc5",
"token": "entity.name.constant"
},
{
"foreground": "005cc5",
"token": "variable.other.constant"
},
{
"foreground": "005cc5",
"token": "variable.language"
},
{
"foreground": "6f42c1",
"token": "entity"
},
{
"foreground": "6f42c1",
"token": "entity.name"
},
{
"foreground": "24292e",
"token": "variable.parameter.function"
},
{
"foreground": "22863a",
"token": "entity.name.tag"
},
{
"foreground": "d73a49",
"token": "keyword"
},
{
"foreground": "d73a49",
"token": "storage"
},
{
"foreground": "d73a49",
"token": "storage.type"
},
{
"foreground": "24292e",
"token": "storage.modifier.package"
},
{
"foreground": "24292e",
"token": "storage.modifier.import"
},
{
"foreground": "24292e",
"token": "storage.type.java"
},
{
"foreground": "032f62",
"token": "string"
},
{
"foreground": "032f62",
"token": "punctuation.definition.string"
},
{
"foreground": "032f62",
"token": "string punctuation.section.embedded source"
},
{
"foreground": "005cc5",
"token": "support"
},
{
"foreground": "005cc5",
"token": "meta.property-name"
},
{
"foreground": "e36209",
"token": "variable"
},
{
"foreground": "24292e",
"token": "variable.other"
},
{
"foreground": "b31d28",
"fontStyle": "bold italic underline",
"token": "invalid.broken"
},
{
"foreground": "b31d28",
"fontStyle": "bold italic underline",
"token": "invalid.deprecated"
},
{
"foreground": "fafbfc",
"background": "b31d28",
"fontStyle": "italic underline",
"token": "invalid.illegal"
},
{
"foreground": "fafbfc",
"background": "d73a49",
"fontStyle": "italic underline",
"token": "carriage-return"
},
{
"foreground": "b31d28",
"fontStyle": "bold italic underline",
"token": "invalid.unimplemented"
},
{
"foreground": "b31d28",
"token": "message.error"
},
{
"foreground": "24292e",
"token": "string source"
},
{
"foreground": "005cc5",
"token": "string variable"
},
{
"foreground": "032f62",
"token": "source.regexp"
},
{
"foreground": "032f62",
"token": "string.regexp"
},
{
"foreground": "032f62",
"token": "string.regexp.character-class"
},
{
"foreground": "032f62",
"token": "string.regexp constant.character.escape"
},
{
"foreground": "032f62",
"token": "string.regexp source.ruby.embedded"
},
{
"foreground": "032f62",
"token": "string.regexp string.regexp.arbitrary-repitition"
},
{
"foreground": "22863a",
"fontStyle": "bold",
"token": "string.regexp constant.character.escape"
},
{
"foreground": "005cc5",
"token": "support.constant"
},
{
"foreground": "005cc5",
"token": "support.variable"
},
{
"foreground": "005cc5",
"token": "meta.module-reference"
},
{
"foreground": "735c0f",
"token": "markup.list"
},
{
"foreground": "005cc5",
"fontStyle": "bold",
"token": "markup.heading"
},
{
"foreground": "005cc5",
"fontStyle": "bold",
"token": "markup.heading entity.name"
},
{
"foreground": "22863a",
"token": "markup.quote"
},
{
"foreground": "24292e",
"fontStyle": "italic",
"token": "markup.italic"
},
{
"foreground": "24292e",
"fontStyle": "bold",
"token": "markup.bold"
},
{
"foreground": "005cc5",
"token": "markup.raw"
},
{
"foreground": "b31d28",
"background": "ffeef0",
"token": "markup.deleted"
},
{
"foreground": "b31d28",
"background": "ffeef0",
"token": "meta.diff.header.from-file"
},
{
"foreground": "b31d28",
"background": "ffeef0",
"token": "punctuation.definition.deleted"
},
{
"foreground": "22863a",
"background": "f0fff4",
"token": "markup.inserted"
},
{
"foreground": "22863a",
"background": "f0fff4",
"token": "meta.diff.header.to-file"
},
{
"foreground": "22863a",
"background": "f0fff4",
"token": "punctuation.definition.inserted"
},
{
"foreground": "e36209",
"background": "ffebda",
"token": "markup.changed"
},
{
"foreground": "e36209",
"background": "ffebda",
"token": "punctuation.definition.changed"
},
{
"foreground": "f6f8fa",
"background": "005cc5",
"token": "markup.ignored"
},
{
"foreground": "f6f8fa",
"background": "005cc5",
"token": "markup.untracked"
},
{
"foreground": "6f42c1",
"fontStyle": "bold",
"token": "meta.diff.range"
},
{
"foreground": "005cc5",
"token": "meta.diff.header"
},
{
"foreground": "005cc5",
"fontStyle": "bold",
"token": "meta.separator"
},
{
"foreground": "005cc5",
"token": "meta.output"
},
{
"foreground": "586069",
"token": "brackethighlighter.tag"
},
{
"foreground": "586069",
"token": "brackethighlighter.curly"
},
{
"foreground": "586069",
"token": "brackethighlighter.round"
},
{
"foreground": "586069",
"token": "brackethighlighter.square"
},
{
"foreground": "586069",
"token": "brackethighlighter.angle"
},
{
"foreground": "586069",
"token": "brackethighlighter.quote"
},
{
"foreground": "b31d28",
"token": "brackethighlighter.unmatched"
},
{
"foreground": "b31d28",
"token": "sublimelinter.mark.error"
},
{
"foreground": "e36209",
"token": "sublimelinter.mark.warning"
},
{
"foreground": "959da5",
"token": "sublimelinter.gutter-mark"
},
{
"foreground": "032f62",
"fontStyle": "underline",
"token": "constant.other.reference.link"
},
{
"foreground": "032f62",
"fontStyle": "underline",
"token": "string.other.link"
}
],
"colors": {
"editor.foreground": "#24292e",
"editor.background": "#ffffff",
"editor.selectionBackground": "#c8c8fa",
"editor.inactiveSelectionBackground": "#fafbfc",
"editor.lineHighlightBackground": "#fafbfc",
"editorCursor.foreground": "#24292e",
"editorWhitespace.foreground": "#959da5",
"editorIndentGuide.background": "#959da5",
"editorIndentGuide.activeBackground": "#24292e",
"editor.selectionHighlightBorder": "#fafbfc"
}
}

93
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/theme/nord.json vendored Normal file
View File

@ -0,0 +1,93 @@
{
"base": "vs-dark",
"inherit": true,
"rules": [
{
"background": "2E3440",
"token": ""
},
{
"foreground": "616e88",
"token": "comment"
},
{
"foreground": "a3be8c",
"token": "string"
},
{
"foreground": "b48ead",
"token": "constant.numeric"
},
{
"foreground": "81a1c1",
"token": "constant.language"
},
{
"foreground": "81a1c1",
"token": "keyword"
},
{
"foreground": "81a1c1",
"token": "storage"
},
{
"foreground": "81a1c1",
"token": "storage.type"
},
{
"foreground": "8fbcbb",
"token": "entity.name.class"
},
{
"foreground": "8fbcbb",
"fontStyle": " bold",
"token": "entity.other.inherited-class"
},
{
"foreground": "88c0d0",
"token": "entity.name.function"
},
{
"foreground": "81a1c1",
"token": "entity.name.tag"
},
{
"foreground": "8fbcbb",
"token": "entity.other.attribute-name"
},
{
"foreground": "88c0d0",
"token": "support.function"
},
{
"foreground": "f8f8f0",
"background": "f92672",
"token": "invalid"
},
{
"foreground": "f8f8f0",
"background": "ae81ff",
"token": "invalid.deprecated"
},
{
"foreground": "b48ead",
"token": "constant.color.other.rgb-value"
},
{
"foreground": "ebcb8b",
"token": "constant.character.escape"
},
{
"foreground": "8fbcbb",
"token": "variable.other.constant"
}
],
"colors": {
"editor.foreground": "#D8DEE9",
"editor.background": "#2E3440",
"editor.selectionBackground": "#434C5ECC",
"editor.lineHighlightBackground": "#3B4252",
"editorCursor.foreground": "#D8DEE9",
"editorWhitespace.foreground": "#434C5ECC"
}
}

2
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/ts.worker.js vendored
View File

File diff suppressed because one or more lines are too long

20
packages/node_modules/@node-red/editor-client/src/vendor/monaco/dist/ts.worker.js.LICENSE.txt vendored
View File

@ -1,6 +1,14 @@
/*!-----------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Version: 0.33.0(4b1abad427e58dbedc1215d99a0902ffc885fcd4)
* Released under the MIT license
* https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
*-----------------------------------------------------------------------------*/
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */