CSpell Dictionaries

https://github.com/streetsidesoftware/cspell-dicts
Admin
CSpell Dictionaries is a collection of natural language, programming, and specialized dictionaries...
Tokens:610,287
Snippets:9,105
Trust Score:9.3
License:GPL-3.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Setup

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/README.md

Prepare the repository by installing dependencies and running the setup script.

```sh
pnpm i
pnpm run setup
```

--------------------------------

### Local Installation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/fr_FR_90/README.md

Install the dictionary locally as a development dependency.

```sh
npm install -D @cspell/dict-fr-reforme
```

--------------------------------

### Local Installation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/fa_IR/README.md

Install the Persian dictionary locally using npm.

```sh
npm install -D @cspell/dict-fa-ir
```

--------------------------------

### Install dictionary-ru

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/ru_RU/src/hunspell/readme.md

Use npm to install the package in a Node.js environment.

```sh
npm install dictionary-ru
```

--------------------------------

### Install Windows build tools

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/n-api.md

Command to install the necessary C/C++ toolchain on Windows.

```bash
npm install --global windows-build-tools
```

--------------------------------

### Install the dictionary package

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/uk_UA/src/hunspell/readme.md

Use npm to install the dictionary-uk package in a Node.js environment.

```sh
npm install dictionary-uk
```

--------------------------------

### Install People Names Dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/people-names/README.md

Install the dictionary as a development dependency in your project.

```sh
npm install -D @cspell/dict-people-names
```

--------------------------------

### JavaScript constructor example

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/n-api.md

A standard JavaScript constructor function and instantiation example.

```js
function MyObject(param) {
  this.param = param;
}

const arg = 'hello';
const value = new MyObject(arg);
```

--------------------------------

### Install Redis Dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/redis/README.md

Install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-redis
```

--------------------------------

### Install Italian Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/it_IT/README.md

Install the Italian dictionary package locally using npm.

```sh
npm install -D @cspell/dict-it-it
```

--------------------------------

### Install the dictionary package

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/pt_BR/src/hunspell/readme.md

Use npm to install the dictionary-pt package in a Node.js environment.

```sh
npm install dictionary-pt
```

--------------------------------

### wasi.start(instance)

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/wasi.md

Starts the execution of the WebAssembly instance.

```APIDOC
## wasi.start(instance)

### Description
Executes the _start function of the provided WebAssembly instance, initiating the WASI application.

### Parameters
- **instance** (WebAssembly.Instance) - Required - The instantiated WebAssembly module.
```

--------------------------------

### server.listen()

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/net.md

Starts the server listening for connections.

```APIDOC
## server.listen()

### Description
Starts the server listening for connections. This method is asynchronous and emits the 'listening' event upon success.

### Parameters
- **handle** (Object) - Optional - A handle object.
- **options** (Object) - Optional - Configuration options.
- **path** (string) - Optional - Path for IPC servers.
- **port** (number) - Optional - Port for TCP servers.
- **host** (string) - Optional - Host for TCP servers.
- **backlog** (number) - Optional - Maximum length of the queue of pending connections.
- **callback** (Function) - Optional - Listener for the 'listening' event.
```

--------------------------------

### Install macOS build tools

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/n-api.md

Command to install the necessary C/C++ toolchain on macOS.

```bash
xcode-select --install
```

--------------------------------

### port.start()

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/worker_threads.md

Starts receiving messages on the MessagePort.

```APIDOC
## port.start()

### Description
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.
```

--------------------------------

### Install Dictionaries via npm

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/README.md

Commands for installing dictionaries locally or from the npm registry.

```sh
npm install -g
```

```sh
npm install -g @cspell/dict-<name>
```

--------------------------------

### Install Arabic Dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/ar/README.md

Install the Arabic dictionary package locally using npm.

```sh
npm install -D @cspell/dict-ar
```

--------------------------------

### Install French Dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/fr_FR/README.md

Install the French dictionary package locally using npm.

```sh
npm install -D @cspell/dict-fr-fr
```

--------------------------------

### Start V8 heap profiler

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/cli.md

Starts the V8 heap profiler on startup and writes the profile to disk upon process exit.

```console
$ node --heap-prof index.js
$ ls *.heapprofile
Heap.20190409.202950.15293.0.001.heapprofile
```

--------------------------------

### Install Catalan Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/ca/static/install.md

Install the Catalan dictionary as a development dependency using npm.

```sh
npm install -D @cspell/dict-ca
```

--------------------------------

### repl.start([options])

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/repl.md

Creates and starts a REPLServer instance. The options object allows customization of the prompt, input/output streams, evaluation logic, and terminal behavior.

```APIDOC
## repl.start([options])

### Description
The `repl.start()` method creates and starts a `repl.REPLServer` instance. If `options` is a string, it is used as the input prompt.

### Parameters
- **options** (Object|string) - Optional - Configuration object or prompt string.
  - **prompt** (string) - Optional - The input prompt to display. Default: '> '
  - **input** (stream.Readable) - Optional - The Readable stream for input. Default: process.stdin
  - **output** (stream.Writable) - Optional - The Writable stream for output. Default: process.stdout
  - **terminal** (boolean) - Optional - If true, output is treated as a TTY terminal.
  - **eval** (Function) - Optional - Function used for evaluating input.
  - **useColors** (boolean) - Optional - If true, enables ANSI color styling.
  - **useGlobal** (boolean) - Optional - If true, uses the global object as the context.
  - **ignoreUndefined** (boolean) - Optional - If true, suppresses output for undefined results.
  - **writer** (Function) - Optional - Function to format output.
  - **completer** (Function) - Optional - Function for custom Tab auto completion.
  - **replMode** (symbol) - Optional - Sets strict or sloppy mode.
  - **breakEvalOnSigint** (boolean) - Optional - Stops evaluation on SIGINT.
  - **preview** (boolean) - Optional - Enables autocomplete and output previews.

### Returns
- **repl.REPLServer** - The started REPL instance.
```

--------------------------------

### Get Negotiated Cipher Information

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/tls.md

Example of the object returned by tlsSocket.getCipher() containing cipher suite details.

```json
{
    "name": "AES128-SHA256",
    "standardName": "TLS_RSA_WITH_AES_128_CBC_SHA256",
    "version": "TLSv1.2"
}
```

--------------------------------

### Initialize and run a WASI instance

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/wasi.md

Demonstrates setting up the WASI environment and executing a WebAssembly module.

```js
'use strict';
const fs = require('fs');
const { WASI } = require('wasi');
const wasi = new WASI({
  args: process.argv,
  env: process.env,
  preopens: {
    '/sandbox': '/some/real/path/that/wasm/can/access'
  }
});
const importObject = { wasi_snapshot_preview1: wasi.wasiImport };

(async () => {
  const wasm = await WebAssembly.compile(fs.readFileSync('./demo.wasm'));
  const instance = await WebAssembly.instantiate(wasm, importObject);

  wasi.start(instance);
})();
```

--------------------------------

### VSCode Configuration (CDN)

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/id_ID/README.md

Configure VSCode to use the Indonesia dictionary from a CDN. This is useful for quick setup without local installation.

```jsonc
{
  "cSpell.import": ["https://cdn.jsdelivr.net/npm/@cspell/dict-id-id@1/cspell-ext.json"],
  "cSpell.language": "id, id-ID"
}
```

--------------------------------

### Local Installation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/id_ID/README.md

Install the Indonesia dictionary locally using npm. This is typically done as a development dependency.

```sh
npm install -D @cspell/dict-id-id
```

--------------------------------

### VSCode Configuration (CDN)

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/bn/README.md

Configure VSCode to use the Bengali dictionary via CDN. This is useful for quick setup without local installation.

```jsonc
{
  "cSpell.import": ["https://cdn.jsdelivr.net/npm/@cspell/dict-bn@1/cspell-ext.json"],
  "cSpell.language": "bn",
}
```

--------------------------------

### Create a REPLServer instance

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/repl.md

Instances can be created using the repl.start() method or the new keyword.

```javascript
const repl = require('repl');

const options = { useColors: true };

const firstInstance = repl.start(options);
const secondInstance = new repl.REPLServer(options);
```

--------------------------------

### Run a Node.js instance in C++

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/embedding.md

Demonstrates the initialization of a Node.js environment using CommonEnvironmentSetup, executing JavaScript, and spinning the event loop.

```cpp
int RunNodeInstance(MultiIsolatePlatform* platform,
                    const std::vector<std::string>& args,
                    const std::vector<std::string>& exec_args) {
  int exit_code = 0;

  // Setup up a libuv event loop, v8::Isolate, and Node.js Environment.
  std::vector<std::string> errors;
  std::unique_ptr<CommonEnvironmentSetup> setup =
      CommonEnvironmentSetup::Create(platform, &errors, args, exec_args);
  if (!setup) {
    for (const std::string& err : errors)
      fprintf(stderr, "%s: %s\n", args[0].c_str(), err.c_str());
    return 1;
  }

  Isolate* isolate = setup->isolate();
  Environment* env = setup->env();

  {
    Locker locker(isolate);
    Isolate::Scope isolate_scope(isolate);
    // The v8::Context needs to be entered when node::CreateEnvironment() and
    // node::LoadEnvironment() are being called.
    Context::Scope context_scope(setup->context());

    // Set up the Node.js instance for execution, and run code inside of it.
    // There is also a variant that takes a callback and provides it with
    // the `require` and `process` objects, so that it can manually compile
    // and run scripts as needed.
    // The `require` function inside this script does *not* access the file
    // system, and can only load built-in Node.js modules.
    // `module.createRequire()` is being used to create one that is able to
    // load files from the disk, and uses the standard CommonJS file loader
    // instead of the internal-only `require` function.
    MaybeLocal<Value> loadenv_ret = node::LoadEnvironment(
        env,
        "const publicRequire ="
        "  require('module').createRequire(process.cwd() + '/');"
        "globalThis.require = publicRequire;"
        "require('vm').runInThisContext(process.argv[1]);");

    if (loadenv_ret.IsEmpty())  // There has been a JS exception.
      return 1;

    exit_code = node::SpinEventLoop(env).FromMaybe(1);

    // node::Stop() can be used to explicitly stop the event loop and keep
    // further JavaScript from running. It can be called from any thread,
    // and will act like worker.terminate() if called from another thread.
    node::Stop(env);
  }

  return exit_code;
}
```

--------------------------------

### VSCode Configuration (CDN)

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/gd/README.md

Configure VSCode to use the Scottish Gaelic dictionary via CDN. This is useful for quick setup without local installation.

```jsonc
{
  "cSpell.import": ["https://cdn.jsdelivr.net/npm/@cspell/dict-gd@1/cspell-ext.json"],
  "cSpell.language": "gd"
}
```

--------------------------------

### replServer.setupHistory(historyPath, callback)

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/repl.md

Initializes a history log file for a programmatically created REPL instance.

```APIDOC
## replServer.setupHistory(historyPath, callback)

### Description
Initializes a history log file for the REPL instance. This is required when working with REPL instances created programmatically.

### Parameters
- **historyPath** (string) - Required - The path to the history file.
- **callback** (Function) - Required - Called when history writes are ready or upon error.
  - **err** (Error) - Error object if initialization fails.
  - **repl** (repl.REPLServer) - The REPL instance.
```

--------------------------------

### Fetching JSON via http.get()

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/http.md

Example demonstrating how to perform a GET request, validate the response status and content type, and parse the resulting JSON data.

```js
http.get('http://nodejs.org/dist/index.json', (res) => {
  const { statusCode } = res;
  const contentType = res.headers['content-type'];

  let error;
  // Any 2xx status code signals a successful response but
  // here we're only checking for 200.
  if (statusCode !== 200) {
    error = new Error('Request Failed.\n' +
                      `Status Code: ${statusCode}`);
  } else if (!/^application\/json/.test(contentType)) {
    error = new Error('Invalid content-type.\n' +
                      `Expected application/json but received ${contentType}`);
  }
  if (error) {
    console.error(error.message);
    // Consume response data to free up memory
    res.resume();
    return;
  }

  res.setEncoding('utf8');
  let rawData = '';
  res.on('data', (chunk) => { rawData += chunk; });
  res.on('end', () => {
    try {
      const parsedData = JSON.parse(rawData);
      console.log(parsedData);
    } catch (e) {
      console.error(e.message);
    }
  });
}).on('error', (e) => {
  console.error(`Got error: ${e.message}`);
});
```

--------------------------------

### Configure VSCode with CDN for Norwegian Bokmål Dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/nb_NO/README.md

Configure VSCode to use the Norwegian Bokmål dictionary via a CDN. This approach avoids local installation and is useful for quick setup or environments where local package management is restricted.

```json
{
  "cSpell.import": ["https://cdn.jsdelivr.net/npm/@cspell/dict-nb-no@2/cspell-ext.json"],
  "cSpell.language": "nb, nb-no"
}
```

--------------------------------

### server.listen(options[, callback])

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/net.md

Starts a server listening for connections using an options object to configure port, host, path, and other server settings.

```APIDOC
## server.listen(options[, callback])

### Description
Start a server listening for connections using an options object. Supports TCP and IPC configurations.

### Parameters
- **options** (Object) - Required - Configuration object (port, host, path, backlog, exclusive, readableAll, writableAll, ipv6Only, signal).
- **callback** (Function) - Optional - Callback function.

### Returns
- **net.Server**
```

--------------------------------

### Install Hungarian Dictionary for CSpell

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/hu_HU/README.md

Install the Hungarian dictionary locally using npm. This is required for local installation.

```sh
npm install -D @cspell/dict-hu-hu
```

--------------------------------

### Create and use a VM context

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/vm.md

Demonstrates how to initialize a context object and execute code within it, showing that the context remains isolated from the main global scope.

```javascript
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
```

--------------------------------

### LaTeX Table Environment Setup

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/latex/test/snapshots/verify.test.mjs.md

This snippet demonstrates the beginning of a LaTeX table environment, including centering and defining the tabular structure with column specifications and rules.

```latex
\begin{table}[h]
    \centering
```

```latex
\begin{tabular}{crrr|rrr}
```

```latex
%chktex 44
```

```latex
\toprule
```

```latex
\multirow{3}{*}{System}
```

```latex
& \multicolumn{6}{c}{Classification error}\\
```

```latex
\cmidrule(l){2-7}
```

--------------------------------

### Install Bulgarian Dictionary for CSpell

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/bg_BG/README.md

Install the Bulgarian dictionary as a development dependency using npm. This command is used for local installation.

```sh
npm install -D @cspell/dict-bg-bg
```

--------------------------------

### Install Swiss German Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/de_CH/README.md

Install the Swiss German dictionary package locally using npm. This is the first step for local installation.

```sh
npm install -D @cspell/dict-de-ch
```

--------------------------------

### Implement a QUIC Server

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/quic.md

Example of creating a QUIC socket and listening for incoming sessions and streams.

```javascript
'use strict';

const key = getTLSKeySomehow();
const cert = getTLSCertSomehow();

const { createQuicSocket } = require('net');

// Create the QUIC UDP IPv4 socket bound to local IP port 1234
const socket = createQuicSocket({ endpoint: { port: 1234 } });

socket.on('session', async (session) => {
  // A new server side session has been created!

  // The peer opened a new stream!
  session.on('stream', (stream) => {
    // Let's say hello
    stream.end('Hello World');

    // Let's see what the peer has to say...
    stream.setEncoding('utf8');
    stream.on('data', console.log);
    stream.on('end', () => console.log('stream ended'));
  });

  const uni = await session.openStream({ halfOpen: true });
  uni.write('hi ');
  uni.end('from the server!');
});

// Tell the socket to operate as a server using the given
// key and certificate to secure new connections, using
// the fictional 'hello' application protocol.
(async function() {
  await socket.listen({ key, cert, alpn: 'hello' });
  console.log('The socket is listening for sessions!');
})();
```

--------------------------------

### server.listen()

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/https.md

Starts the HTTPS server listening for encrypted connections.

```APIDOC
## server.listen()

### Description
Starts the HTTPS server listening for encrypted connections. This method is identical to server.listen() from net.Server.
```

--------------------------------

### Create an HTTPS server with key and certificate

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/https.md

Initializes an HTTPS server using a private key and certificate file.

```javascript
// 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);
```

```javascript
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);
```

--------------------------------

### Implement a context-aware addon

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/addons.md

Demonstrates how to use NODE_MODULE_INIT to create an addon that supports multiple Node.js environments by managing per-instance data.

```cpp
#include <node.h>

using namespace v8;

class AddonData {
 public:
  explicit AddonData(Isolate* isolate):
      call_count(0) {
    // Ensure this per-addon-instance data is deleted at environment cleanup.
    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);
  }

  // Per-addon data.
  int call_count;

  static void DeleteInstance(void* data) {
    delete static_cast<AddonData*>(data);
  }
};

static void Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
  // Retrieve the per-addon-instance data.
  AddonData* data =
      reinterpret_cast<AddonData*>(info.Data().As<External>()->Value());
  data->call_count++;
  info.GetReturnValue().Set((double)data->call_count);
}

// Initialize this addon to be context-aware.
NODE_MODULE_INIT(/* exports, module, context */) {
  Isolate* isolate = context->GetIsolate();

  // Create a new instance of `AddonData` for this instance of the addon and
  // tie its life cycle to that of the Node.js environment.
  AddonData* data = new AddonData(isolate);

  // Wrap the data in a `v8::External` so we can pass it to the method we
  // expose.
  Local<External> external = External::New(isolate, data);

  // Expose the method `Method` to JavaScript, and make sure it receives the
  // per-addon-instance data we created above by passing `external` as the
  // third parameter to the `FunctionTemplate` constructor.
  exports->Set(context,
               String::NewFromUtf8(isolate, "method").ToLocalChecked(),
               FunctionTemplate::New(isolate, Method, external)
                  ->GetFunction(context).ToLocalChecked()).FromJust();
}
```

--------------------------------

### Demonstrate init hook lifecycle

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/async_hooks.md

Shows how resources can be initialized and destroyed without being used.

```js
require('net').createServer().listen(function() { this.close(); });
// OR
clearTimeout(setTimeout(() => {}, 10));
```

--------------------------------

### Trace Atomics.wait output example

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/cli.md

Example output format when using the --trace-atomics-wait flag to monitor Atomics.wait calls.

```text
(node:15701) [Thread 0] Atomics.wait(<address> + 0, 1, inf) started
(node:15701) [Thread 0] Atomics.wait(<address> + 0, 1, inf) did not wait because the values mismatched
(node:15701) [Thread 0] Atomics.wait(<address> + 0, 0, 10) started
(node:15701) [Thread 0] Atomics.wait(<address> + 0, 0, 10) timed out
(node:15701) [Thread 0] Atomics.wait(<address> + 4, 0, inf) started
(node:15701) [Thread 1] Atomics.wait(<address> + 4, -1, inf) started
(node:15701) [Thread 0] Atomics.wait(<address> + 4, 0, inf) was woken up by another thread
(node:15701) [Thread 1] Atomics.wait(<address> + 4, -1, inf) was woken up by another thread
```

--------------------------------

### quicsocket.listen([options])

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/quic.md

Initializes the QUIC server with the provided configuration options, including TLS settings and QUIC protocol parameters.

```APIDOC
## quicsocket.listen([options])

### Description
Starts the QUIC server and configures it using the provided options object. This method handles TLS handshake settings, certificate management, and QUIC-specific transport parameters.

### Parameters
- **options** (Object) - Optional - Configuration object containing:
  - **ca** (string|string[]|Buffer|Buffer[]) - CA certificate(s) for peer validation.
  - **cert** (string|string[]|Buffer|Buffer[]) - Certificate chains in PEM format.
  - **key** (string|string[]|Buffer|Buffer[]|Object[]) - Private keys in PEM format.
  - **ciphers** (string) - Cipher suite specification.
  - **congestionAlgorithm** (string) - Must be 'reno' or 'cubic'. Default: 'reno'.
  - **maxStreamsBidi** (number) - Maximum number of bidirectional streams.
  - **maxStreamsUni** (number) - Maximum number of unidirectional streams.
  - **earlyData** (boolean) - Enable or disable 0RTT early data. Default: true.
  - **highWaterMark** (number) - Internal buffer limit for QuicStream. Default: 16384.
  - **idleTimeout** (number) - Idle timeout duration.
  - **passphrase** (string) - Shared passphrase for private keys or PFX.
  - **pfx** (string|string[]|Buffer|Buffer[]|Object[]) - PFX or PKCS12 encoded private key and certificate chain.
```

--------------------------------

### Install pycparser dependency

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/win32/src/generator/README.md

Installs the required pycparser library via pip.

```bash
> pip install pycparser
```

--------------------------------

### Start a REPL with a custom prompt

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/repl.md

Initializes a REPL instance using a string as the input prompt.

```javascript
const repl = require('repl');

// a Unix style prompt
repl.start('$ ');
```

--------------------------------

### Local Installation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/hy/README.md

Install the Armenian dictionary package locally using npm.

```sh
npm install -D @cspell/dict-hy
```

--------------------------------

### Create and use a DNS Resolver

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/dns.md

Demonstrates initializing a custom Resolver instance and performing DNS lookups using both Promise chains and async/await syntax.

```javascript
const { Resolver } = require('dns').promises;
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').then((addresses) => {
  // ...
});

// Alternatively, the same code can be written using async-await style.
(async function() {
  const addresses = await resolver.resolve4('example.org');
})();
```

--------------------------------

### Define a WebAssembly text format file

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/wasi.md

A sample WAT file that imports fd_write to print 'hello world' to stdout.

```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
    )
)
```

--------------------------------

### Install the Swedish dictionary package

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/sv/src/hunspell/readme.md

Use npm to install the package in a Node.js environment.

```sh
npm install dictionary-sv
```

--------------------------------

### Compare node-addon-api and N-API C implementation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/n-api.md

Demonstrates the difference in verbosity between using the C++ wrapper and the raw C N-API functions to create an object with a property.

```cpp
Object obj = Object::New(env);
obj["foo"] = String::New(env, "bar");
```

```cpp
napi_status status;
napi_value object, string;
status = napi_create_object(env, &object);
if (status != napi_ok) {
  napi_throw_error(env, ...);
  return;
}

status = napi_create_string_utf8(env, "bar", NAPI_AUTO_LENGTH, &string);
if (status != napi_ok) {
  napi_throw_error(env, ...);
  return;
}

status = napi_set_named_property(env, object, "foo", string);
if (status != napi_ok) {
  napi_throw_error(env, ...);
  return;
}
```

--------------------------------

### Install Swedish Dictionary via npm

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/sv/README.md

Install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-sv
```

--------------------------------

### Handle HTTP upgrade events

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/http.md

Demonstrates setting up a server and client to handle the 'upgrade' event for protocol switching.

```javascript
const http = require('http');

// Create an HTTP server
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
server.on('upgrade', (req, socket, head) => {
  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
               'Upgrade: WebSocket\r\n' +
               'Connection: Upgrade\r\n' +
               '\r\n');

  socket.pipe(socket); // echo back
});

// Now that server is running
server.listen(1337, '127.0.0.1', () => {

  // make a request
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      'Connection': 'Upgrade',
      'Upgrade': 'websocket'
    }
  };

  const req = http.request(options);
  req.end();

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!');
    socket.end();
    process.exit(0);
  });
});
```

--------------------------------

### Install Serbian Dictionary via npm

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/sr_Cyrl/README.md

Install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-sr-cyrl
```

--------------------------------

### Initialize N-API Module

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/n-api.md

Uses the NAPI_MODULE_INIT macro to register the addon module entry point.

```c
// addon_node.c
#include <node_api.h>
#include "addon.h"

NAPI_MODULE_INIT() {
  // This function body is expected to return a `napi_value`.
  // The variables `napi_env env` and `napi_value exports` may be used within
  // the body, as they are provided by the definition of `NAPI_MODULE_INIT()`.
  return create_addon(env);
}
```

--------------------------------

### Install Slovenian dictionary via npm

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/sl_SI/README.md

Install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-sl-si
```

--------------------------------

### Install Slovak Dictionary via NPM

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/sk_SK/README.md

Install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-sk-sk
```

--------------------------------

### server.listen(path[, backlog][, callback])

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/net.md

Starts an IPC server listening for connections on the given path.

```APIDOC
## server.listen(path[, backlog][, callback])

### Description
Start an IPC server listening for connections on the given path.

### Parameters
- **path** (string) - Required - Path the server should listen to.
- **backlog** (number) - Optional - Common parameter for listen functions.
- **callback** (Function) - Optional - Callback function.

### Returns
- **net.Server**
```

--------------------------------

### Using the Console class

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/console.md

Shows how to instantiate a custom Console object to direct output to specific streams.

```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
```

--------------------------------

### Implement a Hello World Addon with N-API

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/addons.md

Use this C++ implementation to create a stable native addon that remains compatible across Node.js versions.

```cpp
// hello.cc using N-API
#include <node_api.h>

namespace demo {

napi_value Method(napi_env env, napi_callback_info args) {
  napi_value greeting;
  napi_status status;

  status = napi_create_string_utf8(env, "world", NAPI_AUTO_LENGTH, &greeting);
  if (status != napi_ok) return nullptr;
  return greeting;
}

napi_value init(napi_env env, napi_value exports) {
  napi_status status;
  napi_value fn;

  status = napi_create_function(env, nullptr, 0, Method, nullptr, &fn);
  if (status != napi_ok) return nullptr;

  status = napi_set_named_property(env, exports, "hello", fn);
  if (status != napi_ok) return nullptr;
  return exports;
}

NAPI_MODULE(NODE_GYP_MODULE_NAME, init)

}  // namespace demo
```

--------------------------------

### Install the Romanian dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/ro_RO/src/hunspell/readme.md

Use npm to install the dictionary package in a Node.js environment.

```sh
npm install dictionary-ro
```

--------------------------------

### Create Certificate Instance

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/crypto.md

Demonstrates the legacy method of instantiating the Certificate class.

```javascript
const crypto = require('crypto');

const cert1 = new crypto.Certificate();
const cert2 = crypto.Certificate();
```

--------------------------------

### Access process.execArgv and process.argv

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/process.md

Demonstrates the difference between Node.js-specific command-line options and standard script arguments.

```js
['--harmony']
```

```js
['/usr/local/bin/node', 'script.js', '--version']
```

--------------------------------

### Handle spawn failure

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/child_process.md

Demonstrates how to detect if a process failed to start.

```js
const { spawn } = require('child_process');
const subprocess = spawn('bad_command');

subprocess.on('error', (err) => {
  console.error('Failed to start subprocess.');
});
```

--------------------------------

### wasi.start(instance)

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/wasi.md

Attempts to execute a WebAssembly instance as a WASI command by invoking its _start() export.

```APIDOC
## wasi.start(instance)

### Description
Attempts to begin execution of the provided WebAssembly instance as a WASI command. Requires the instance to export a WebAssembly.Memory object named 'memory'.

### Parameters
- **instance** (WebAssembly.Instance) - Required - The WebAssembly instance to execute.
```

--------------------------------

### Install Azerbaijani Dictionary via NPM

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/az_AZ/README.md

Install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-az-az
```

--------------------------------

### server.listen([port[, host[, backlog]]][, callback])

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/net.md

Starts a TCP server listening for connections on the given port and host.

```APIDOC
## server.listen([port[, host[, backlog]]][, callback])

### Description
Start a TCP server listening for connections on the given port and host.

### Parameters
- **port** (number) - Optional - Port to listen on.
- **host** (string) - Optional - Host to listen on.
- **backlog** (number) - Optional - Common parameter for listen functions.
- **callback** (Function) - Optional - Callback function.

### Returns
- **net.Server**
```

--------------------------------

### Handle QuicServerSession creation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/quic.md

Demonstrates how to listen for new QUIC server sessions and attach event listeners to them.

```js
const { createQuicSocket } = require('net');

const options = getOptionsSomehow();
const server = createQuicSocket({ server: options });

server.on('session', (session) => {
  // Attach session event listeners.
});

server.listen();
```

--------------------------------

### Install Yeoman and generator-cspell-dicts

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/generator-cspell-dicts/README.md

Global installation of the Yeoman CLI and linking the local generator package.

```bash
npm install -g yo
npm link
```

--------------------------------

### Install Vietnamese Dictionary via NPM

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/vi_VN/README.md

Install the dictionary package as a development dependency in your project.

```sh
npm install -D @cspell/dict-vi-vn
```

--------------------------------

### Install Romanian Dictionary via NPM

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/ro_RO/README.md

Install the dictionary package as a development dependency in your project.

```sh
npm install -D @cspell/dict-ro-ro
```

--------------------------------

### Context-Aware Addon Initialization

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/addons.md

Using NODE_MODULE_INITIALIZER to support multiple contexts in runtimes like Electron.

```cpp
using namespace v8;

extern "C" NODE_MODULE_EXPORT void
NODE_MODULE_INITIALIZER(Local<Object> exports,
                        Local<Value> module,
                        Local<Context> context) {
  /* Perform addon initialization steps here. */
}
```

--------------------------------

### Install Mongolian Dictionary for CSpell

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/mn_MN/README.md

Install the Mongolian dictionary package locally as a development dependency.

```sh
npm install -D @cspell/dict-mn-mn
```

--------------------------------

### Listen for the 'connect' event

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/http.md

Demonstrates setting up an HTTP tunneling proxy and making a CONNECT request to it.

```js
const http = require('http');
const net = require('net');
const { URL } = require('url');

// Create an HTTP tunneling proxy
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
proxy.on('connect', (req, clientSocket, head) => {
  // Connect to an origin server
  const { port, hostname } = new URL(`http://${req.url}`);
  const serverSocket = net.connect(port || 80, hostname, () => {
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n' +
                    'Proxy-agent: Node.js-Proxy\r\n' +
                    '\r\n');
    serverSocket.write(head);
    serverSocket.pipe(clientSocket);
    clientSocket.pipe(serverSocket);
  });
});

// Now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {

  // Make a request to a tunneling proxy
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80'
  };

  const req = http.request(options);
  req.end();

  req.on('connect', (res, socket, head) => {
    console.log('got connected!');

    // Make a request over an HTTP tunnel
    socket.write('GET / HTTP/1.1\r\n' +
                 'Host: www.google.com:80\r\n' +
                 'Connection: close\r\n' +
                 '\r\n');
    socket.on('data', (chunk) => {
      console.log(chunk.toString());
    });
    socket.on('end', () => {
      proxy.close();
    });
  });
});
```

--------------------------------

### VSCode Settings for Local Installation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/mk/README.md

Configure VSCode to use the locally installed Macedonian dictionary.

```jsonc
{
  "cSpell.import": ["@cspell/dict-mk/cspell-ext.json"],
  "cSpell.language": "mk, mk-cyrl"
}
```

--------------------------------

### Install Latvian Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/lv/README.md

Install the Latvian dictionary as a development dependency using npm.

```sh
npm install -D @cspell/dict-lv
```

--------------------------------

### quicsocket.listen([options])

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/quic.md

Starts listening for incoming QUIC connections on the socket.

```APIDOC
## quicsocket.listen([options])

### Description
Configures and starts the QUIC socket to listen for incoming connections.

### Parameters
- **options** (Object) - Optional
  - **alpn** (string) - Required - A required ALPN protocol identifier.
  - **ca** (string|string[]|Buffer|Buffer[]) - Optional - Optionally override the trusted CA certificates.
```

--------------------------------

### server.listen(handle[, backlog][, callback])

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/net.md

Starts a server listening for connections on a given handle that has already been bound to a port, a Unix domain socket, or a Windows named pipe.

```APIDOC
## server.listen(handle[, backlog][, callback])

### Description
Start a server listening for connections on a given `handle` that has already been bound to a port, a Unix domain socket, or a Windows named pipe.

### Parameters
- **handle** (Object) - Required - The handle object (server, socket, or object with fd).
- **backlog** (number) - Optional - Common parameter for listen functions.
- **callback** (Function) - Optional - Callback function.

### Returns
- **net.Server**
```

--------------------------------

### VSCode Settings for Local Installation

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/hy/README.md

Configure VSCode to use the locally installed Armenian dictionary.

```jsonc
{
  "cSpell.import": ["@cspell/dict-hy/cspell-ext.json"],
  "cSpell.language": "hy, hy-AM"
}
```

--------------------------------

### Initialize context-aware modules

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/n-api.md

Use NAPI_MODULE_INIT for modules that may be loaded multiple times in a process.

```c
NAPI_MODULE_INIT() {
  napi_value answer;
  napi_status result;

  status = napi_create_int64(env, 42, &answer);
  if (status != napi_ok) return NULL;

  status = napi_set_named_property(env, exports, "answer", answer);
  if (status != napi_ok) return NULL;

  return exports;
}
```

--------------------------------

### Setting up per-process state for Node.js embedding

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/embedding.md

Initializes Node.js CLI arguments and the V8 platform required for running a Node.js instance.

```cpp
int main(int argc, char** argv) {
  argv = uv_setup_args(argc, argv);
  std::vector<std::string> args(argv, argv + argc);
  std::vector<std::string> exec_args;
  std::vector<std::string> errors;
  // Parse Node.js CLI options, and print any errors that have occurred while
  // trying to parse them.
  int exit_code = node::InitializeNodeWithArgs(&args, &exec_args, &errors);
  for (const std::string& error : errors)
    fprintf(stderr, "%s: %s\n", args[0].c_str(), error.c_str());
  if (exit_code != 0) {
    return exit_code;
  }

  // Create a v8::Platform instance. `MultiIsolatePlatform::Create()` is a way
  // to create a v8::Platform instance that Node.js can use when creating
  // Worker threads. When no `MultiIsolatePlatform` instance is present,
  // Worker threads are disabled.
  std::unique_ptr<MultiIsolatePlatform> platform =
      MultiIsolatePlatform::Create(4);
  V8::InitializePlatform(platform.get());
  V8::Initialize();

  // See below for the contents of this function.
  int ret = RunNodeInstance(platform.get(), args, exec_args);

  V8::Dispose();
  V8::ShutdownPlatform();
  return ret;
}
```

--------------------------------

### Install Hebrew Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/he/README.md

Install the Hebrew dictionary package locally as a development dependency.

```sh
npm install -D @cspell/dict-he
```

--------------------------------

### Install GIS Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/gis/README.md

Install the GIS dictionary package locally using npm.

```sh
npm install -D @cspell/dict-gis
```

--------------------------------

### Run the Node.js server

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/synopsis.md

Command to execute the hello-world.js script and the expected terminal output.

```console
$ node hello-world.js
```

```console
Server running at http://127.0.0.1:3000/
```

--------------------------------

### Install GDScript Dictionary for CSpell

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/gdscript/README.md

Install the GDScript dictionary as a development dependency using npm.

```sh
npm install -D @cspell/dict-gdscript
```

--------------------------------

### Install Basque Dictionary via NPM

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/eu/README.md

Install the dictionary package as a development dependency in your project.

```sh
npm install -D @cspell/dict-eu
```

--------------------------------

### Install Estonian Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/et-EE/static/install.md

Install the Estonian dictionary as a development dependency using npm.

```sh
npm install -D @cspell/dict-et-ee
```

--------------------------------

### Install @cspell/dict-en-shared Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/en_shared/static/install.md

Use this command to install the en-shared dictionary as a development dependency in your project.

```sh
npm install -D @cspell/dict-en-shared
```

--------------------------------

### Retrieve Server Address Information

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/net.md

Demonstrates creating a server and retrieving its assigned address and port after it begins listening.

```javascript
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());
});
```

--------------------------------

### Install British English Dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/en_GB/README.md

Use npm to install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-en-gb
```

--------------------------------

### Local Installation of Greek Dictionary

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/el/README.md

Install the Greek dictionary package locally as a development dependency.

```sh
npm install -D @cspell/dict-el
```

--------------------------------

### Initialize Buffer instances

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/node/src/api/buffer.md

Demonstrates various ways to allocate and populate Buffer objects, including zero-filled, uninitialized, and data-initialized buffers.

```javascript
// Creates a zero-filled Buffer of length 10.
const buf1 = Buffer.alloc(10);

// Creates a Buffer of length 10,
// filled with bytes which all have the value `1`.
const buf2 = Buffer.alloc(10, 1);

// Creates an uninitialized buffer of length 10.
// This is faster than calling Buffer.alloc() but the returned
// Buffer instance might contain old data that needs to be
// overwritten using fill(), write(), or other functions that fill the Buffer's
// contents.
const buf3 = Buffer.allocUnsafe(10);

// Creates a Buffer containing the bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3]);

// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
// are all truncated using `(value & 255)` to fit into the range 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1']);

// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
// [116, 195, 169, 115, 116] (in decimal notation)
const buf6 = Buffer.from('tést');

// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1');
```

--------------------------------

### Install Clojure Dictionary Locally

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/clojure/static/install.md

Install the Clojure dictionary as a development dependency using npm.

```sh
npm install -D @cspell/dict-clojure
```

--------------------------------

### Install Portuguese Dictionary via NPM

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/pt_PT/README.md

Use this command to install the dictionary package as a development dependency.

```sh
npm install -D @cspell/dict-pt-pt
```

--------------------------------

### Configure Vim dictionary via CDN

Source: https://github.com/streetsidesoftware/cspell-dicts/blob/main/dictionaries/vim/README.md

Configuration examples for using the Vim dictionary directly from a CDN.

```jsonc
{
  "cSpell.import": ["https://cdn.jsdelivr.net/npm/@cspell/dict-vim@1/cspell-ext.json"],
  "cSpell.dictionaries": ["vim"],
}
```

```jsonc
{
  "import": ["https://cdn.jsdelivr.net/npm/@cspell/dict-vim@1/cspell-ext.json"],
  "dictionaries": ["vim"],
}
```

```yaml
import:
  - https://cdn.jsdelivr.net/npm/@cspell/dict-vim@1/cspell-ext.json
dictionaries:
  - vim
```
Tokens:
Raw