open-index/open-npm huggingface dataset:
npm package: @gc/rust-walker-win32-x64-msvc
Description: This is the **x86_64-pc-windows-msvc** binary for `@gc/rust-walker`
Latest version: 0.0.4

# `@gc/rust-walker-win32-x64-msvc`

This is the **x86_64-pc-windows-msvc** binary for `@gc/rust-walker`
npm package: @gcanossa/gas-http-api
Description: Google Apps Script http api microframework
Author: Gianmaria Canossa
Latest version: 1.0.2

# @gcanossa/gas-http-api
Google Apps Script http api microframework, inspired by expressJs.

## Installation

In order to isntall the package in your project just execute the command:
```
npm i -D @gcanossa/gas-http-api
```

## Usage

The library expose an **appBuilder** function which allows you to create and configure an http response handler for the special function events **doGet** and **doPost** of the Google Apps Script environment.

You can create and configure an **app function** and use it to handle both special events.

```ts

const app = appBuilder(builder => {
  builder
    .use((req, res)=>{
      console.log(req.contextPath)
    })
    .get('/api/:name', (req, res) => {
      respond(res).text(`Hello ${req.pathParams!.name}`);
    })
    .all('/view/:name', (req, res) => {
      respond(res).view('index.e2e', {name: req.pathParams!.name});
    })
});

function doGet(e: GoogleAppsScript.Events.DoGet){
  return app(e);
}

function doPost(e: GoogleAppsScript.Events.DoPost){
  return app(e);
}

```

It is possible to insert special segments in the mapping url pattern in the form of **:*name*** which will be matched against the real request setting the keys of the *params* member of the request object.

To build the response an helper is available wich allows and simplifies the production of text, downloadable content, json and templated html views.

```ts
interface HttpResponseHelper {
  ok():void;
  view(path:string, params:ViewParams):void;
  json(content:any):void;
  text(content:string):void;
  download(content:string, filename: string):void;
  error(error:string):void;
}

```
npm package: @gcas/fuse-shared-library
Description: Cross-platform FUSE libraries for OSX/Linux
Author: Andrew Osheroff
Latest version: 1.1.2
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# fuse-shared-library
Cross-platform prebuilt FUSE libraries for OSX/Linux.

This module will dynamically require either [fuse-shared-library-linux](https://github.com/fuse-friends/fuse-shared-library-linux) or [fuse-shared-library-darwin](https://github.com/fuse-friends/fuse-shared-library-darwin).

## Installation
```
npm i fuse-shared-library --save
```

## Usage

``` js
const libfuse = require('fuse-shared-library')

console.log(libfuse.lib) // path to the shared library
console.log(libfuse.include) // path to the include folder

// tells you if libfuse has been configured on this machine
libfuse.isConfigured(function (err, yes) { })

// configure libfuse on this machine (requires root access)
// but only needs to run once
libfuse.configure(function (err) { })

// unconfigures libfuse on this machine
libfuse.unconfigure(function (err) { })
```

You should configure libfuse using the above API before using the
shared library, otherwise the program using fuse will error.

You can remove the folder manually if you want to remove fuse or use the
`unconfigure` api listed above.

The shared library itself is contained within the module and not copied
or installed anywhere. You should move the shared library next to your
program after linking it as that is where your binary will try and load it from.

Using a GYP file this can be done like this:

```
{
  "targets": [{
    "target_name": "fuse_example",
    "include_dirs": [
      # include it like this
      "<!(node -e \"require('fuse-shared-library/include')\")"
    ],
    "libraries": [
      # link it like this
      "<!(node -e \"require('fuse-shared-library/lib')\")"
    ],
    "sources": [
      "your_program.cc"
    ]
  }, {
    # setup a postinstall target that copies the shared library
    # next to the produces node library
    "target_name": "postinstall",
    "type": "none",
    "dependencies": ["fuse_example"],
    "copies": [{
      "destination": "build/Release",
      "files": [ "<!(node -e \"require('fuse-shared-library/lib')\")" ],
    }]
  }]
}
```

## License

MIT
npm package: @gcas/fuse-shared-library-darwin
Description: A module containing the dylib needed to run FUSE on Mac (darwin).
Author: Mathias Buus
Latest version: 1.1.3
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# fuse-shared-library-darwin

A module containing the dylib needed to run FUSE on Mac (darwin).

```
npm install fuse-shared-library-darwin
```

Includes programmatic access to setup the kernel extension as well
as part of an install step.

## Usage

``` js
const libfuse = require('fuse-shared-library-darwin')

console.log(libfuse.lib) // path to the shared library
console.log(libfuse.include) // path to the include folder

// tells you if libfuse has been configured on this machine
libfuse.isConfigured(function (err, yes) { })

// configure libfuse on this machine (requires root access)
// but only needs to run once
libfuse.configure(function (err) { })

// unconfigures libfuse on this machine
libfuse.unconfigure(function (err) { })
```

You should configure libfuse using the above API before using the
shared library, otherwise the program using fuse will error.

When configuring the only thing this module does is copy
the fuse kernel extension and some helpers to `/Library/Filesystems/osxfuse.fs`,
and tries to load the kernel extension once.

The first time it loads on mac a user prompt will trigger that allows
you to accept the kernel extension.

You can remove the folder manually if you want to remove fuse or use the
`unconfigure` api listed above.

The shared library itself is contained within the module and not copied
or installed anywhere. You should move the shared library next to your
program after linking it as that is where your binary will try and load it from.

Using a GYP file this can be done like this:

```
{
  "targets": [{
    "target_name": "fuse_example",
    "include_dirs": [
      # include it like this
      "<!(node -e \"require('fuse-shared-library-darwin/include')\")"
    ],
    "libraries": [
      # link it like this
      "<!(node -e \"require('fuse-shared-library-darwin/lib')\")"
    ],
    "sources": [
      "your_program.cc"
    ]
  }, {
    # setup a postinstall target that copies the shared library
    # next to the produces node library
    "target_name": "postinstall",
    "type": "none",
    "dependencies": ["fuse_example"],
    "copies": [{
      "destination": "build/Release",
      "files": [ "<!(node -e \"require('fuse-shared-library-darwin/lib')\")" ],
    }]
  }]
}
```

## Development

Use the `./fetch-osxfuse.sh` script to fetch OSX fuse
and unwrap the shared library and more.

## License

MIT

See the [osxfuse license](https://github.com/osxfuse/osxfuse/blob/master/LICENSE.txt) for the terms involving commercial redistribution,
for the osxfuse part.
npm package: @gcas/fuse-shared-library-linux
Description: A module containing the .so file and configuration scripts necessary for FUSE on Linux.
Author: Andrew Osheroff
Latest version: 1.0.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# fuse-shared-library-linux
A module containing the .so file and configuration scripts necessary for FUSE on Linux.

```
npm install fuse-shared-library-linux
```

Includes programmatic access to setup the FUSE device and kernel extension as part of a configuration step.

## Usage

``` js
const libfuse = require('fuse-shared-library-linux')

console.log(libfuse.lib) // path to the shared library
console.log(libfuse.include) // path to the include folder

// tells you if libfuse has been configured on this machine
libfuse.isConfigured(function (err, yes) { })

// configure libfuse on this machine (requires root access)
// but only needs to run once
libfuse.configure(function (err) { })

// unconfigures libfuse on this machine
libfuse.unconfigure(function (err) { })
```

You should configure libfuse using the above API before using the
shared library, otherwise the program using fuse will error.

You can remove the folder manually if you want to remove fuse or use the
`unconfigure` api listed above.

The shared library itself is contained within the module and not copied
or installed anywhere. You should move the shared library next to your
program after linking it as that is where your binary will try and load it from.

Using a GYP file this can be done like this:

```
{
  "targets": [{
    "target_name": "fuse_example",
    "include_dirs": [
      # include it like this
      "<!(node -e \"require('fuse-shared-library-linux/include')\")"
    ],
    "libraries": [
      # link it like this
      "<!(node -e \"require('fuse-shared-library-linux/lib')\")"
    ],
    "sources": [
      "your_program.cc"
    ]
  }, {
    # setup a postinstall target that copies the shared library
    # next to the produces node library
    "target_name": "postinstall",
    "type": "none",
    "dependencies": ["fuse_example"],
    "copies": [{
      "destination": "build/Release",
      "files": [ "<!(node -e \"require('fuse-shared-library-linux/lib')\")" ],
    }]
  }]
}
```

## License

MIT
npm package: @gcas/fuse-shared-library-linux-arm
Description: A module containing the .so file and configuration scripts necessary for FUSE on ARM based Linux.
Author: Andrew Osheroff
Latest version: 1.0.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# fuse-shared-library-linux-arm
A module containing the .so file and configuration scripts necessary for FUSE on ARM Linux.

```
npm install fuse-shared-library-linux-arm
```

Includes programmatic access to setup the FUSE device and kernel extension as part of a configuration step.

## Usage

``` js
const libfuse = require('fuse-shared-library-linux-arm')

console.log(libfuse.lib) // path to the shared library
console.log(libfuse.include) // path to the include folder

// tells you if libfuse has been configured on this machine
libfuse.isConfigured(function (err, yes) { })

// configure libfuse on this machine (requires root access)
// but only needs to run once
libfuse.configure(function (err) { })

// unconfigures libfuse on this machine
libfuse.unconfigure(function (err) { })
```

You should configure libfuse using the above API before using the
shared library, otherwise the program using fuse will error.

You can remove the folder manually if you want to remove fuse or use the
`unconfigure` api listed above.

The shared library itself is contained within the module and not copied
or installed anywhere. You should move the shared library next to your
program after linking it as that is where your binary will try and load it from.

Using a GYP file this can be done like this:

```
{
  "targets": [{
    "target_name": "fuse_example",
    "include_dirs": [
      # include it like this
      "<!(node -e \"require('fuse-shared-library-linux-arm/include')\")"
    ],
    "libraries": [
      # link it like this
      "<!(node -e \"require('fuse-shared-library-linux-arm/lib')\")"
    ],
    "sources": [
      "your_program.cc"
    ]
  }, {
    # setup a postinstall target that copies the shared library
    # next to the produces node library
    "target_name": "postinstall",
    "type": "none",
    "dependencies": ["fuse_example"],
    "copies": [{
      "destination": "build/Release",
      "files": [ "<!(node -e \"require('fuse-shared-library-linux-arm/lib')\")" ],
    }]
  }]
}
```

## License

MIT
npm package: @gcas/fuse-shared-library-win32
Description: A module containing path to the DLL needed to run WinFsp on Windows (Work in progress).
Author: Raymond Hammarling
Latest version: 0.1.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# fuse-shared-library-win32 (Work in progress)

Install [WinFsp](https://github.com/billziss-gh/winfsp/releases) (both Core
and Developer components), then...

```
npm install fuse-shared-library-win32
```

## Usage

``` js
const winFspFuse = require('fuse-shared-library-win32')

console.log(winFspFuse.lib) // path to the .lib file to link with
console.log(winFspFuse.include) // path to the include folder
console.log(winFspFuse.bin) // path to the .dll file

// pthreads (used by fuse-native)
console.log(winFspFuse.pthreads.lib) // path to the .lib file to link with
console.log(winFspFuse.pthreads.include) // path to the include folder
console.log(winFspFuse.pthreads.bin) // path to the .dll file
```

You should move the shared library next to your program after linking it
as that is where your binary will try and load it from.

Using a GYP file this can be done like this:

```
{
  "targets": [{
    "target_name": "fuse_example",
    "include_dirs": [
      # include it like this
      "<!@(node -e \"require('fuse-shared-library-win32/include')\")"
    ],
    "libraries": [
      # link it like this
      "<!@(node -e \"require('fuse-shared-library-win32/lib')\")"
    ],
    "sources": [
      "your_program.cc"
    ]
  }, {
    # setup a postinstall target that copies the shared library
    # next to the produces node library
    "target_name": "postinstall",
    "type": "none",
    "dependencies": ["fuse_example"],
    "copies": [{
      "destination": "build/Release",
      # expanding a variable to a list here does not seem to work somehow (node-gyp 5.1.0)
      "files": [
        "<!(node -e \"console.log(require('fuse-shared-library-win32').bin)\")",
        "<!(node -e \"console.log(require('fuse-shared-library-win32').pthreads.bin)\")"
      ],
    }]
  }]
}
```

## License

MIT
npm package: @gcas/imaged
Description: Lightweight TypeScript tools for manipulating images in the browser.
Author: Valeriu Paloș
Latest version: 1.3.1

# GCAS Imaged Tools

A no-dependency toolset for manipulating images in the browser.
Currently only `Crop` is implemented.

### Features:

-   Lightweight;
-   No-dependencies;
-   Uses Shadow DOM (doesn't affect external CSS);
-   Invoked with a simple call;
-   Does not change existing DOM elements (other than inserting a single absolutely-positioned div);
-   TypeScript.

## Crop ([demo](https://vpalos.com/2023/03/19/ad-hoc-image-cropper/))

In-place cropping tool intended for (but not limited to) selecting images for upload. Just invoke the `Crop` object on any image you have in the DOM.

> See demo in `/test/crop.html` file.

Doesn't alter the original image element at all, it just overlays ontop of it; this means you can place and style your source image however you like before cropping.

### Layout requirement

**Important!** The source image must reside in a relatively positioned container and the container must take the exact size of the image.

> I found this to be is the easiest way to implement perfect crop layout regardless of scenario. Making the tool auto-responsive without this requirement would complicate things a lot (observers, events, altering the DOM... and still not perfect).

### Usage

-   Load `dist/Crop.js` on your page, however you like:
    -   use `<script src=".../Crop.js">` in the browser;
    -   use `import Crop from "@gcas/imaged/dist/Crop";` if in modules (e.g. typescript);
-   Ensure the source image exists on the page in the following layout:
    ```html
    <div style="position: relative; display: inline-flex">
        <img id="source" src="..." ... crossorigin />
    </div>
    ```
    -   `position: relative` is important so Crop can take the size of this container (`absolute` or `fixed` are also fine);
    -   `display: inline-flex` is only used here to make sure the container takes the exact size of the image;
    -   `crossorigin` is also important (required for internal canvas);
-   Once the image loads, call `new Crop("#source", { /* options */ })`;
-   Done.

### Documentation

I had no time for that; please see the comments in `src/Crop.ts` and the exposed (public) methods.

See also the `test/crop.html` file for usage examples.
npm package: @gcas/rdiff
Description: NodeJS native librsync binding (sync & async).
Author: Valeriu Paloș
Latest version: 1.0.3

# Native librsync binding for NodeJS.

Initially based on the [`node-rdiff` package](https://www.npmjs.com/package/node-rdiff) but diverged significantly.

## Platforms supported

-   Linux (x64): YES
-   Windows (x64): YES
-   MacOS: Not yet, planned (should not be hard to add).

## Example

The synchronous api (`*Sync` functions):

```js
var a = "a.txt"; // Contains "hello".
var b = "b.txt"; // Contains "hello world".

// Compute difference from `a` to `b`.
rdiff.signatureSync(a, `${a}.sig`);
rdiff.deltaSync(`${a}.sig`, b, `${a}.delta`);

// Patch `a` so that it becomes equal to `b`.
rdiff.patchSync(a, `${a}.delta`, `${a}.patched`);
```

The callback async api:

```js
rdiff.signature(a, `${a}.sig`, function (err) {
    rdiff.delta(`${a}.sig`, b, `${a}.delta`, function (err) {
        rdiff.patch(a, `${a}.delta`, `${a}.patched`, function (error) {
            if (error) {
                return console.error(error);
            }

            // File `a.patched` now equals `b`.
        });
    });
});
```

The promise async api (`*Async` functions, recommended):

```js
await rdiff.signatureAsync(a, `${a}.sig`);
await rdiff.deltaAsync(`${a}.sig`, b, `${a}.delta`);
await rdiff.patchAsync(a, `${a}.delta`, `${a}.patched`);
// `a` should equal `a.patched`
```
npm package: @gcas/rsync
Description: NodeJS native librsync binding (sync & async).
Author: Valeriu Paloș
Latest version: 1.0.2
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# !Deprecated!

This package is deprecated in favor of [@gcas/rdiff](https://www.npmjs.com/package/@gcas/rdiff).

# Native librsync binding for NodeJS.

Initially based on the [`node-rdiff` package](https://www.npmjs.com/package/node-rdiff).

## Platforms supported

-   Linux (x64): YES
-   Windows (x64): YES
-   MacOS: Not yet, planned (should not be hard to add).

## Example

The synchronous api (`*Sync` functions):

```js
var a = "a.txt"; // Contains "hello".
var b = "b.txt"; // Contains "hello world".

// Compute difference from `a` to `b`.
rdiff.signatureSync(a, `${a}.sig`);
rdiff.deltaSync(`${a}.sig`, b, `${a}.delta`);

// Patch `a` so that it becomes equal to `b`.
rdiff.patchSync(a, `${a}.delta`, `${a}.patched`);
```

The callback async api:

```js
rdiff.signature(a, `${a}.sig`, function (err) {
    rdiff.delta(`${a}.sig`, b, `${a}.delta`, function (err) {
        rdiff.patch(a, `${a}.delta`, `${a}.patched`, function (error) {
            if (error) {
                return console.error(error);
            }

            // File `a.patched` now equals `b`.
        });
    });
});
```

The promise async api (`*Async` functions, recommended):

```js
await rdiff.signatureAsync(a, `${a}.sig`);
await rdiff.deltaAsync(`${a}.sig`, b, `${a}.delta`);
await rdiff.patchAsync(a, `${a}.delta`, `${a}.patched`);
// `a` should equal `a.patched`
```