### Socks v1 Connection Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/socks/docs/migratingFromV1.md

This is the original getting started example from socks v1, demonstrating how to create a SOCKS connection.

```javascript
var Socks = require('socks');

var options = {
    proxy: {
        ipaddress: "202.101.228.108",
        port: 1080,
        type: 5
    },
    target: {
        host: "google.com",
        port: 80
    },
    command: 'connect'
};

Socks.createConnection(options, function(err, socket, info) {
    if (err)
        console.log(err);
    else {
        socket.write("GET / HTTP/1.1\nHost: google.com\n\n");
        socket.on('data', function(data) {
            console.log(data.length);
            console.log(data);
        });

        // PLEASE NOTE: sockets need to be resumed before any data will come in or out as they are paused right before this callback is fired.
        socket.resume();

        // 569
        // <Buffer 48 54 54 50 2f 31 2e 31 20 33 30 31 20 4d 6f 76 65 64 20 50 65...
    }
});
```

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

### Socks v2 Connection Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/socks/docs/migratingFromV1.md

This example shows the equivalent of the v1 getting started example, adapted for socks v2. Note the renamed 'destination' option and the callback receiving a single 'result' object.

```javascript
const SocksClient = require('socks').SocksClient;

let options = {
    proxy: {
        ipaddress: "202.101.228.108",
        port: 1080,
        type: 5
    },
    destination: {
        host: "google.com",
        port: 80
    },
    command: 'connect'
};

SocksClient.createConnection(options, function(err, result) {
    if (err)
        console.log(err);
    else {
        result.socket.write("GET / HTTP/1.1\nHost: google.com\n\n");
        result.socket.on('data', function(data) {
            console.log(data.length);
            console.log(data);
        });

        // 569
        // <Buffer 48 54 54 50 2f 31 2e 31 20 33 30 31 20 4d 6f 76 65 64 20 50 65...
    }
});
```

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

### Example Usage: Full Server Setup

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/router/README.md

Demonstrates a complete server setup using the router module, including middleware like compression and body-parsing, and defining multiple routes.

```APIDOC
## Full Server Example

### Description
This example illustrates how to initialize an HTTP server, configure a main router with middleware, define API routes with specific HTTP methods and request body parsing, and handle responses.

### Key Components
- **Server Initialization**: Uses Node.js `http` module.
- **Router Setup**: Creates a main `router` instance and mounts a sub-router (`api`) for API-specific routes.
- **Middleware**: Includes `compression` for response compression and `bodyParser.json` for parsing JSON request bodies.
- **Route Definitions**: Shows `GET` for a message endpoint and `PATCH` for updating the message, including basic request validation and error responses.

### Request Examples
#### Get Message
```bash
curl http://127.0.0.1:8080
```

#### Set Message
```bash
curl http://127.0.0.1:8080/api/set-message -X PATCH -H "Content-Type: application/json" -d '{"value":"Cats!"}'
```

### Code Snippet
```javascript
// import our modules
var http         = require('http')
var Router       = require('router')
var finalhandler = require('finalhandler')
var compression  = require('compression')
var bodyParser   = require('body-parser')

// store our message to display
var message = "Hello World!"

// initialize the router & server and add a final callback.
var router = Router()
var server = http.createServer(function onRequest(req, res) {
  router(req, res, finalhandler(req, res))
})

// use some middleware and compress all outgoing responses
router.use(compression())

// handle `GET` requests to `/message`
router.get('/message', function (req, res) {
  res.statusCode = 200
  res.setHeader('Content-Type', 'text/plain; charset=utf-8')
  res.end(message + '\n')
})

// create and mount a new router for our API
var api = Router()
router.use('/api/', api)

// add a body parsing middleware to our API
api.use(bodyParser.json())

// handle `PATCH` requests to `/api/set-message`
api.patch('/set-message', function (req, res) {
  if (req.body.value) {
    message = req.body.value

    res.statusCode = 200
    res.setHeader('Content-Type', 'text/plain; charset=utf-8')
    res.end(message + '\n')
  } else {
    res.statusCode = 400
    res.setHeader('Content-Type', 'text/plain; charset=utf-8')
    res.end('Invalid API Syntax\n')
  }
})

// make our http server listen to connections
server.listen(8080)
```
```

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

### Install anymatch

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/anymatch/README.md

Install the anymatch module using npm. This is the initial setup step before using the library.

```sh
npm install anymatch
```

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

### Basic Optionator Setup and Usage

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/macos/node_modules/optionator/README.md

Demonstrates how to initialize Optionator with options, parse command-line arguments, and generate help text. This is a common starting point for integrating Optionator into a Node.js application.

```javascript
var optionator = require('optionator')({
    prepend: 'Usage: cmd [options]',
    append: 'Version 1.0.0',
    options: [{ 
        option: 'help',
        alias: 'h',
        type: 'Boolean',
        description: 'displays help'
    }, {
        option: 'count',
        alias: 'c',
        type: 'Int',
        description: 'number of things',
        example: 'cmd --count 2'
    }]
});

var options = optionator.parseArgv(process.argv);
if (options.help) {
    console.log(optionator.generateHelp());
}
...
```

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

### Basic Express.js Server Setup

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/express/Readme.md

This snippet demonstrates the fundamental setup for an Express.js server, including requiring the module, creating an app instance, defining a basic route, and starting the server.

```javascript
const express = require('express')
const app = express()

app.get('/', function (req, res) {
  res.send('Hello World')
})

app.listen(3000)
```

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

### Full Server Example with Middleware and API Router

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/router/README.md

Sets up an HTTP server using the router module, including compression middleware, a GET route for a message, and a nested API router with body parsing for a PATCH route.

```javascript
// import our modules
var http         = require('http')
var Router       = require('router')
var finalhandler = require('finalhandler')
var compression  = require('compression')
var bodyParser   = require('body-parser')

// store our message to display
var message = "Hello World!"

// initialize the router & server and add a final callback.
var router = Router()
var server = http.createServer(function onRequest(req, res) {
  router(req, res, finalhandler(req, res))
})

// use some middleware and compress all outgoing responses
router.use(compression())

// handle `GET` requests to `/message`
router.get('/message', function (req, res) {
  res.statusCode = 200
  res.setHeader('Content-Type', 'text/plain; charset=utf-8')
  res.end(message + '\n')
})

// create and mount a new router for our API
var api = Router()
router.use('/api/', api)

// add a body parsing middleware to our API
api.use(bodyParser.json())

// handle `PATCH` requests to `/api/set-message`
api.patch('/set-message', function (req, res) {
  if (req.body.value) {
    message = req.body.value

    res.statusCode = 200
    res.setHeader('Content-Type', 'text/plain; charset=utf-8')
    res.end(message + '\n')
  } else {
    res.statusCode = 400
    res.setHeader('Content-Type', 'text/plain; charset=utf-8')
    res.end('Invalid API Syntax\n')
  }
})

// make our http server listen to connections
server.listen(8080)
```

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

### Dry Run Install Script

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/README.md

Preview the installation process without actually installing code-server. This is useful for understanding the steps involved.

```bash
curl -fsSL https://code-server.dev/install.sh | sh -s -- --dry-run
```

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

### Basic Application Insights Setup and Start

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/applicationinsights/README.md

Configure Application Insights with your instrumentation key and start data collection. The instrumentation key can also be set via the APPINSIGHTS_INSTRUMENTATIONKEY environment variable.

```javascript
let appInsights = require("applicationinsights");
appInsights.setup("_your_ikey_").start();
```

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

### Basic HTTP Server with Router

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/router/README.md

Set up a basic HTTP server using Node.js and the router module. This example demonstrates creating a router instance, defining a GET route for the root path, and handling requests.

```javascript
var finalhandler = require('finalhandler')
var http         = require('http')
var Router       = require('router')

var router = Router()
router.get('/', function (req, res) {
  res.setHeader('Content-Type', 'text/plain; charset=utf-8')
  res.end('Hello World!')
})

var server = http.createServer(function(req, res) {
  router(req, res, finalhandler(req, res))
})

server.listen(3000)
```

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

### Quick Start: Connect via SOCKS Proxy

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/socks/README.md

Example of connecting to a destination host and port through a SOCKS proxy using async/await. Ensure the proxy details and destination are correctly configured.

```javascript
const options = {
  proxy: {
    host: '159.203.75.200', // ipv4 or ipv6 or hostname
    port: 1080,
    type: 5 // Proxy version (4 or 5)
  },

  command: 'connect', // SOCKS command (createConnection factory function only supports the connect command)

  destination: {
    host: '192.30.253.113', // github.com (hostname lookups are supported with SOCKS v4a and 5)
    port: 80
  }
};

// Async/Await
try {
  const info = await SocksClient.createConnection(options);

  console.log(info.socket);
  // <Socket ...>  (this is a raw net.Socket that is established to the destination host through the given proxy server)
} catch (err) {
  // Handle errors
}
```

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

### Install code-point-at

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/code-point-at/readme.md

Install the package using npm.

```bash
$ npm install --save code-point-at
```

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

### Install serve-static

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/serve-static/README.md

Install the serve-static module using npm.

```sh
$ npm install serve-static
```

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

### Quick Start: Connect via SOCKS Proxy

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/socks/README.md

Example of connecting to a destination host and port through a SOCKS proxy using the SocksClient. Supports async/await, promises, and callbacks for connection establishment.

```javascript
const options = {
  proxy: {
    host: '159.203.75.200', // ipv4 or ipv6 or hostname
    port: 1080,
    type: 5 // Proxy version (4 or 5)
  },

  command: 'connect', // SOCKS command (createConnection factory function only supports the connect command)

  destination: {
    host: '192.30.253.113', // github.com (hostname lookups are supported with SOCKS v4a and 5)
    port: 80
  }
};

// Async/Await
try {
  const info = await SocksClient.createConnection(options);

  console.log(info.socket);
  // <Socket ...>  (this is a raw net.Socket that is established to the destination host through the given proxy server)
} catch (err) {
  // Handle errors
}

// Promises
SocksClient.createConnection(options)
.then(info => {
  console.log(info.socket);
  // <Socket ...>  (this is a raw net.Socket that is established to the destination host through the given proxy server)
})
.catch(err => {
  // Handle errors
});

// Callbacks
SocksClient.createConnection(options, (err, info) => {
  if (!err) {
    console.log(info.socket);
    // <Socket ...>  (this is a raw net.Socket that is established to the destination host through the given proxy server)
  } else {
    // Handle errors
  }
});
```

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

### Install binary-extensions

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/binary-extensions/readme.md

Install the package using npm.

```bash
$ npm install binary-extensions
```

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

### Installation with component

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/ftp/node_modules/isarray/README.md

Installs the 'isarray' package using the component package manager. This is an alternative installation method for projects using component.

```bash
$ component install juliangruber/isarray
```

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

### Install process-nextick-args

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/process-nextick-args/readme.md

Install the process-nextick-args module using npm.

```bash
npm install --save process-nextick-args
```

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

### balanced.range API Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/brace-expansion/node_modules/balanced-match/README.md

Illustrates how to use the balanced.range function to get the start and end indexes of the first non-nested matching pair of delimiters in a string.

```javascript
var balanced = require('balanced-match');

console.log(balanced.range('(', ')', 'foo(bar(baz))'));
console.log(balanced.range('(', ')', 'foo(bar)baz(qux)'));
console.log(balanced.range('(', ')', 'foo(bar)baz)'));
console.log(balanced.range('(', ')', '(foo(bar)'));
```

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

### Build documentation with verb

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/is-extglob/README.md

Install global dependencies and run verb to generate documentation.

```sh
$ npm install -g verb verb-generate-readme && verb
```

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

### WebSocket Connection Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/https-proxy-agent/README.md

Shows how to use https-proxy-agent with the `ws` library for establishing proxied WebSocket connections. This example requires the `ws` package to be installed.

```javascript
var url = require('url');
var WebSocket = require('ws');
var HttpsProxyAgent = require('https-proxy-agent');

// HTTP/HTTPS proxy to connect to
var proxy = process.env.http_proxy || 'http://168.63.76.32:3128';
console.log('using proxy server %j', proxy);

// WebSocket endpoint for the proxy to connect to
var endpoint = process.argv[2] || 'ws://echo.websocket.org';
var parsed = url.parse(endpoint);
console.log('attempting to connect to WebSocket %j', endpoint);

// create an instance of the `HttpsProxyAgent` class with the proxy server information
var options = url.parse(proxy);

var agent = new HttpsProxyAgent(options);

// finally, initiate the WebSocket connection
var socket = new WebSocket(endpoint, { agent: agent });

socket.on('open', function () {
  console.log('"open" event!');
  socket.send('hello world');
});

socket.on('message', function (data, flags) {
  console.log('"message" event! %j %j', data, flags);
  socket.close();
});
```

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

### Get Byte Offset

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/node-addon-api/doc/dataview.md

Returns the offset, in bytes, from the start of the backing ArrayBuffer where this DataView begins. This indicates the starting position of the data within the buffer.

```cpp
size_t Napi::DataView::ByteOffset() const;
```

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

### Asynchronous Logging Setup

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/spdlog/deps/spdlog/README.md

Demonstrates setting up an asynchronous logger that writes to a file. It shows how to initialize the thread pool before creating the async logger.

```c++
#include "spdlog/async.h"
#include "spdlog/sinks/basic_file_sink.h"
void async_example()
{
    // default thread pool settings can be modified *before* creating the async logger:
    // spdlog::init_thread_pool(8192, 1); // queue with 8k items and 1 backing thread.
    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
    // alternatively:
    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");   
}

```

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

### Clone Express Repository and Install Dependencies

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/express/Readme.md

These commands clone the Express.js repository and install its development dependencies, typically used for running examples or contributing to Express.

```bash
$ git clone git://github.com/expressjs/express.git --depth 1
$ cd express
$ npm install
```

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

### Basic CMake Project Setup

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/spdlog/deps/spdlog/tests/CMakeLists.txt

Initializes the CMake version and project name. It finds the spdlog package and includes utility scripts.

```cmake
cmake_minimum_required(VERSION 3.10)
project(spdlog_utests CXX)

if(NOT TARGET spdlog)
    # Stand-alone build
    find_package(spdlog REQUIRED)
endif()

include(../cmake/utils.cmake)

find_package(PkgConfig)
if(PkgConfig_FOUND)
    pkg_check_modules(systemd libsystemd)
endif()
```

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

### Basic Optionator Setup and Usage

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/optionator/README.md

Demonstrates how to initialize Optionator with custom settings for usage messages and option definitions, and then parse command-line arguments. It includes a conditional check to display help if the 'help' option is present.

```javascript
var optionator = require('optionator')({
    prepend: 'Usage: cmd [options]',
    append: 'Version 1.0.0',
    options: [{
        option: 'help',
        alias: 'h',
        type: 'Boolean',
        description: 'displays help'
    }, {
        option: 'count',
        alias: 'c',
        type: 'Int',
        description: 'number of things',
        example: 'cmd --count 2'
    }]
});

var options = optionator.parseArgv(process.argv);
if (options.help) {
    console.log(optionator.generateHelp());
}
...
```

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

### Install Argon2 with Specific GCC Binary on OSX

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/argon2/README.md

Example command for installing the argon2 library on OSX, specifying the C++ compiler (CXX) to use, such as 'g++-6'. Adjust the compiler name if a different version or compiler is installed.

```bash
$ CXX=g++-6 npm install argon2
```

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

### Router Initialization and Basic Usage

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/macos/node_modules/router/README.md

Demonstrates how to create a router instance and define a simple GET route for the root path.

```APIDOC
## Router(options)

Options:
- `strict` (boolean): When `false` trailing slashes are optional (default: `false`).
- `caseSensitive` (boolean): When `true` the routing will be case sensitive (default: `false`).
- `mergeParams` (boolean): When `true` any `req.params` passed to the router will be merged into the router's `req.params` (default: `false`).

Returns a function with the signature `router(req, res, callback)` where `callback([err])` must be provided to handle errors and fall-through from not handling requests.

## router.get(path, ...[middleware], handler)

Handles a `GET` request for the specified path.

### Description
Handles a `GET` request for the specified path.

### Method
GET

### Endpoint
[Full endpoint path with any path parameters]

### Request Example
```javascript
router.get('/', function (req, res) {
  res.setHeader('Content-Type', 'text/plain; charset=utf-8')
  res.end('Hello World!')
})
```

### Response
#### Success Response (200)
- `text/plain` - "Hello World!"
```

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

### Curl Command to Get Message

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/router/README.md

Example command to retrieve the message from the server using curl.

```bash
curl http://127.0.0.1:8080
```

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

### Basic Argparse Setup and Argument Definition

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/argparse/README.md

Demonstrates how to initialize an ArgumentParser with a description and add various types of arguments like version, string, and optional arguments.

```javascript
#!/usr/bin/env node
'use strict';

const { ArgumentParser } = require('argparse');
const { version } = require('./package.json');

const parser = new ArgumentParser({
  description: 'Argparse example'
});

parser.add_argument('-v', '--version', { action: 'version', version });
parser.add_argument('-f', '--foo', { help: 'foo bar' });
parser.add_argument('-b', '--bar', { help: 'bar foo' });
parser.add_argument('--baz', { help: 'baz bar' });

```

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

### Netmask next() Method Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/netmask/README.md

Shows how to get the next network block of the same size using the next() method.

```javascript
block.next() // Netmask('10.16.0.0/12')
```

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

### Building Documentation with Verb

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/picomatch/README.md

Install the necessary tools and run the command to generate the README.md file using the verb tool.

```sh
npm install -g verbose/verb#dev verb-generate-readme && verb
```

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

### Async Function Compilation and Evaluation Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/degenerator/README.md

Demonstrates how to compile a user-provided synchronous function string into an asynchronous function using degenerator and Node.js's vm module. It includes an example of a Promise-based asynchronous 'get' function.

```typescript
import vm from 'vm';
import degenerator from 'degenerator';

// The `get()` function is Promise-based (error handling omitted for brevity)
function get(endpoint: string) {
  return new Promise((resolve, reject) => {
    var mod = 0 == endpoint.indexOf('https:') ? require('https') : require('http');
    var req = mod.get(endpoint);
    req.on('response', function (res) {
      var data = '';
      res.setEncoding('utf8');
      res.on('data', function (b) { data += b; });
      res.on('end', function () {
        resolve(data);
      });
    });
  });
}

// Convert the JavaScript string provided from the user (assumed to be `str` var)
str = degenerator(str, [ 'get' ]);

// Turn the JS String into a real async function instance
const asyncFn = vm.runInNewContext(`(${str})`, { get });

// Now we can invoke the function asynchronously
asyncFn().then((res) => {
  // Do something with `res`...
});
```

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

### package.json Configuration for node-pre-gyp

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/@mapbox/node-pre-gyp/README.md

Example of how to configure your package.json to use node-pre-gyp, including dependencies, install script, and binary object.

```json
    "dependencies"  : {
      "@mapbox/node-pre-gyp": "1.x"
    },
    "devDependencies": {
      "aws-sdk": "2.x"
    }
    "scripts": {
        "install": "node-pre-gyp install --fallback-to-build"
    },
    "binary": {
        "module_name": "your_module",
        "module_path": "./lib/binding/",
        "host": "https://your_module.s3-us-west-1.amazonaws.com"
    }
```

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

### Install the methods module

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/methods/README.md

Use npm to install the methods module. This is the first step before requiring it in your project.

```bash
$ npm install methods
```

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

### Get Byte Offset

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/node-addon-api/doc/typed_array.md

Returns the offset, in bytes, from the beginning of the backing Napi::ArrayBuffer to the start of this TypedArray's data.

```cpp
size_t Napi::TypedArray::ByteOffset() const;
```

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

### Example Output 1

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/macos/lib/vscode/node_modules/minimist/readme.markdown

Demonstrates the output of parsing simple key-value arguments.

```bash
$ node example/parse.js -a beep -b boop
{ _: [], a: 'beep', b: 'boop' }
```

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

### balanced.range API Example Output

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/brace-expansion/node_modules/balanced-match/README.md

Displays the output of the balanced.range function, showing the start and end indices for matched delimiter pairs.

```bash
$ node example.js
[ 4, 12 ]
[ 4, 8 ]
[ 4, 8 ]
[ 1, 9 ]
```

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

### Get Start Column Helper

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/nan/doc/maybe_types.md

Use Nan::GetStartColumn to call v8::Message#GetStartColumn() compatibly across V8 versions.

```c++
Nan::Maybe<int> Nan::GetStartColumn(v8::Local<v8::Message> msg);
```

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

### Asynchronous Git Status Check

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/node_modules/simple-git/readme.md

An example of an asynchronous function to get the Git status of a working directory. Includes basic error handling.

```javascript
async function status (workingDir) {
   let statusSummary = null;
   try {
      statusSummary = await simpleGit(workingDir).status();
   }
   catch (e) {
      // handle the error
   }

   return statusSummary;
}

// using the async function
status(__dirname + '/some-repo').then(status => console.log(status));
```

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

### Starting the JSON Language Server with Different Communication Channels

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/macos/lib/vscode/extensions/json-language-features/server/README.md

Demonstrates how to launch the JSON language server from the command line, specifying the desired communication protocol.

```bash
vscode-json-languageserver --node-ipc
vscode-json-languageserver --stdio
vscode-json-languageserver --socket=<port>

```

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

### Get Element Size in Bytes

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/node-addon-api/doc/typed_array.md

Returns the size, in bytes, of a single element within the TypedArray. For example, a Float64Array would return 8.

```cpp
uint8_t Napi::TypedArray::ElementSize() const;
```

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

### Clean Build and Install from Binary

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/vscode-sqlite3/CONTRIBUTING.md

Perform a clean build and install from binary to ensure the release works correctly.

```shell
make clean && npm install --fallback-to-build=false
```

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

### Get Readable Stream from File URI

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/get-uri/README.md

Obtain a stream.Readable instance from a file URI. This example demonstrates mapping a 'file:' URI to a fs.ReadStream.

```js
var getUri = require('get-uri');

// `file:` maps to a `fs.ReadStream` instance…
getUri('file:///Users/nrajlich/wat.json', function (err, rs) {
  if (err) throw err;
  rs.pipe(process.stdout);
});
```

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

### Starting the JSON Language Server

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/extensions/json-language-features/server/README.md

Commands to launch the JSON language server with different communication protocols. Install the 'vscode-json-languageserver' npm module first.

```bash
vscode-json-languageserver --node-ipc
```

```bash
vscode-json-languageserver --stdio
```

```bash
vscode-json-languageserver --socket=<port>
```

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

### Install windows-foreground-love

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/windows-foreground-love/README.md

Install the windows-foreground-love package using npm.

```sh
npm install windows-foreground-love
```

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

### Develop windows-foreground-love

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/windows-foreground-love/README.md

Steps to set up the development environment for windows-foreground-love, including installing node-gyp, configuring, building, and testing.

```sh
npm install -g node-gyp
node-gyp configure
node-gyp build
npm test
```

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

### CLI Usage Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/which/README.md

Illustrates the command-line interface for the 'which' utility.

```bash
usage: which [-as] program ...
```

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

### Enabling Testing and Creating Log Directory

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/macos/lib/vscode/node_modules/spdlog/deps/spdlog/example/CMakeLists.txt

This snippet enables CMake testing and creates a directory named 'logs' in the build output directory. This setup is for running and verifying the spdlog examples.

```cmake
enable_testing()
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs")
```

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

### VM with Timeout and Sandbox Options

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/vm2/README.md

Illustrates creating a VM instance with a specified timeout and an empty sandbox object.

```javascript
const {VM} = require('vm2');

const vm = new VM({
    timeout: 1000,
    sandbox: {}
});

vm.run("process.exit()"); // throws ReferenceError: process is not defined
```

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

### Add WebSocket Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/zone.js/CHANGELOG.md

Introduces an example demonstrating the usage of WebSockets with Zone.js.

```javascript
add websockets example ([edb17d2](https://github.com/angular/zone.js/commit/edb17d2))
```

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

### Basic Yazl Usage Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/yazl/README.md

Demonstrates how to create a zip file, add files from the filesystem and other sources, pipe the output, and end the zip process.

```javascript
var yazl = require("yazl");

var zipfile = new yazl.ZipFile();
zipfile.addFile("file1.txt", "file1.txt");
// (add only files, not directories)
zipfile.addFile("path/to/file.txt", "path/in/zipfile.txt");
// pipe() can be called any time after the constructor
zipfile.outputStream.pipe(fs.createWriteStream("output.zip")).on("close", function() {
  console.log("done");
});
// alternate apis for adding files:
zipfile.addReadStream(process.stdin, "stdin.txt", {
  mtime: new Date(),
  mode: parseInt("0100664", 8), // -rw-rw-r--
});
zipfile.addBuffer(new Buffer("hello"), "hello.txt", {
  mtime: new Date(),
  mode: parseInt("0100664", 8), // -rw-rw-r--
});
// call end() after all the files have been added
zipfile.end();
```

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

### Basic IP Address Operations in Node.js

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/ip/README.md

Demonstrates common IP address operations including getting the local IP, comparing addresses, converting formats, and validating formats. Requires the 'ip' package to be installed and required.

```javascript
var ip = require('ip');

ip.address() // my ip address
ip.isEqual('::1', '::0:1'); // true
ip.toBuffer('127.0.0.1') // Buffer([127, 0, 0, 1])
ip.toString(new Buffer([127, 0, 0, 1])) // 127.0.0.1
ip.fromPrefixLen(24) // 255.255.255.0
ip.mask('192.168.1.134', '255.255.255.0') // 192.168.1.0
ip.cidr('192.168.1.134/26') // 192.168.1.128
ip.not('255.255.255.0') // 0.0.0.255
ip.or('192.168.1.134', '0.0.0.255') // 192.168.1.255
ip.isPrivate('127.0.0.1') // true
ip.isV4Format('127.0.0.1'); // true
ip.isV6Format('::ffff:127.0.0.1'); // true
```

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

### Install encodeurl with npm

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/encodeurl/README.md

Install the encodeurl module locally using the npm install command.

```sh
$ npm install encodeurl
```

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

### Install ee-first

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/ee-first/README.md

Install the ee-first module using npm.

```sh
$ npm install ee-first
```

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

### Install code-server

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/README.md

Install code-server using the provided curl script. This automates most of the installation process.

```bash
curl -fsSL https://code-server.dev/install.sh | sh
```

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

### Install raw-body

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/raw-body/README.md

Install the raw-body module using npm. This command installs the package locally in your project.

```sh
npm install raw-body
```

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

### Basic Chokidar Watcher Example

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/chokidar/README.md

A simple example demonstrating how to initialize Chokidar to watch the current directory and log all file system events. This requires the chokidar module to be required first.

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

// One-liner for current directory
chokidar.watch('.').on('all', (event, path) => {
  console.log(event, path);
});
```

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

### Quick Start: Connecting via SOCKS Proxy with Callbacks

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/macos/node_modules/socks/README.md

Establishes a connection to a destination host through a SOCKS proxy using callbacks. Requires the SocksClient to be imported.

```javascript
SocksClient.createConnection(options, (err, info) => {
  if (!err) {
    console.log(info.socket);
    // <Socket ...>  (this is a raw net.Socket that is established to the destination host through the given proxy server)
  } else {
    // Handle errors
  }
});
```

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

### Install native-watchdog

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/lib/vscode/node_modules/native-watchdog/README.md

Install the native-watchdog module using npm. This command fetches and installs the package and its dependencies.

```sh
npm install native-watchdog
```

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

### Install Node.js Router Module

Source: https://github.com/cloudwise-opensource/flyfish/blob/master/lcapCodeServer/linux/node_modules/router/README.md

Install the router module using npm. This command downloads and installs the package locally.

```bash
npm install router
```