open-index/open-npm huggingface dataset:
npm package: @lass-lang/bun-plugin-lass
Description: Bun plugin for Lass language
Author: Long-lazuli
Latest version: 0.0.2

# @lass-lang/bun-plugin-lass

Bun plugin for processing `.lass` files. Transforms Lass source to CSS via `@lass-lang/core`.

## Installation

```bash
bun add @lass-lang/bun-plugin-lass --dev
```

## Usage

### With Bun.build()

```typescript
import lass from "@lass-lang/bun-plugin-lass";

await Bun.build({
  entrypoints: ["./src/index.ts"],
  outdir: "./dist",
  plugins: [lass()],
});
```

### With bunfig.toml (preload)

For automatic `.lass` support without explicit plugin configuration:

```toml
# bunfig.toml
preload = ["@lass-lang/bun-plugin-lass/preload"]
```

Then import `.lass` files directly:

```typescript
import "./styles.lass";
```

## CSS Modules

CSS Modules work with `.module.lass` files:

```typescript
import styles from "./component.module.lass";

element.className = styles.container;
```

For TypeScript, add declarations:

```typescript
// lass.d.ts
declare module "*.lass";

declare module "*.module.lass" {
  const classes: { readonly [key: string]: string };
  export default classes;
}
```

## Options

```typescript
lass({
  verbose: true,  // Enable logging (default: false)
});
```

## Limitations

- **No HMR**: Bun's plugin API doesn't support Hot Module Replacement.
  For development with HMR, use Vite with `@lass-lang/vite-plugin-lass`.

## How It Works

1. Plugin intercepts `.lass` file imports via `onResolve`/`onLoad`
2. Transpiles Lass source to JS module via `@lass-lang/core`
3. Executes JS to extract CSS string
4. Returns CSS to Bun's bundler with `loader: "css"`
5. For `.module.lass`: resolves to virtual `.lass.module.css` path so Bun applies CSS Modules scoping

## Peer Dependencies

- `bun` >=1.0.0

## License

MIT
npm package: @lass-lang/cli
Description: Lass CLI - compile .lass files to CSS
Author: Long-lazuli
Latest version: 0.0.2

# @lass-lang/cli

Command-line interface for compiling `.lass` files to CSS.

## Installation

```bash
pnpm add -g @lass-lang/cli
```

Or use directly with `npx`:

```bash
npx @lass-lang/cli styles.lass
```

## Usage

```bash
# Compile a file and output to stdout
lass styles.lass

# Compile a file to a specific output file
lass styles.lass dist/styles.css

# Compile all .lass files in a directory
lass src/styles/ --out dist/css/

# Read from stdin
echo ".box { color: blue; }" | lass --stdin

# Show help
lass --help

# Show version
lass --version
```

## Options

| Option | Description |
|--------|-------------|
| `-o, --out <dir>` | Output directory (required for directory input) |
| `--stdin` | Read input from stdin |
| `-h, --help` | Show help message |
| `-v, --version` | Show version number |

## Examples

### Single file compilation

```bash
# Output to stdout
lass button.lass

# Output to file
lass button.lass dist/button.css
```

### Directory compilation

```bash
# Compile all .lass files in src/ to dist/
lass src/ --out dist/

# Preserves directory structure:
# src/components/button.lass -> dist/components/button.css
# src/pages/home.lass        -> dist/pages/home.css
```

### Stdin/stdout pipeline

```bash
# Pipe content directly
echo ".card { padding: 16px; }" | lass --stdin

# Use with other tools
cat styles.lass | lass --stdin > styles.css
```

## Programmatic API

The CLI also exports functions for programmatic use:

```typescript
import { compileFile, compileString, compileDirectory } from '@lass-lang/cli';

// Compile a file
const css = await compileFile('styles.lass');

// Compile a string
const css = await compileString('.box { color: blue; }');

// Compile a directory
await compileDirectory('src/styles', 'dist/css');
```

### API Reference

#### `compileFile(inputPath: string): Promise<string>`

Compiles a single `.lass` file and returns the CSS string.

#### `compileString(source: string, filename?: string): Promise<string>`

Compiles Lass source code from a string. The optional `filename` parameter is used for error messages (defaults to `'stdin.lass'`).

#### `compileDirectory(inputDir: string, outputDir: string): Promise<void>`

Compiles all `.lass` files in a directory recursively, writing corresponding `.css` files to the output directory while preserving the directory structure.

#### `findLassFiles(dir: string): Promise<string[]>`

Recursively finds all `.lass` files in a directory.

## Requirements

- Node.js >= 20.0.0

## License

MIT
npm package: @lass-lang/core
Description: Lass language transpiler core
Author: Long-lazuli
Latest version: 0.1.0

# @lass-lang/core

Core transpiler for the Lass language. Converts `.lass` files to executable JavaScript modules that produce CSS.

## Installation

```bash
pnpm add @lass-lang/core
```

## Usage

```typescript
import { transpile } from '@lass-lang/core';

// Transpile Lass source to a JavaScript module
const source = `
.button {
  color: blue;
  padding: 8px 16px;
}
`;

const { code } = transpile(source);
// code is a JS module string that exports the CSS

// Execute the transpiled code to get CSS
const dataUrl = `data:text/javascript;charset=utf-8,${encodeURIComponent(code)}`;
const module = await import(dataUrl);
console.log(module.default); // The CSS string
```

## API

### `transpile(source, options?)`

Transpiles Lass source code to a JavaScript module.

**Parameters:**
- `source` (string): The Lass source code
- `options` (TranspileOptions, optional):
  - `filename` (string): Source file path for error messages
  - `sourceMap` (boolean): Generate source maps (future)

**Returns:** `TranspileResult`
- `code` (string): The generated JavaScript module code
- `map` (string, optional): Source map (future)

### Error Handling

```typescript
import { LassTranspileError, ErrorCategory } from '@lass-lang/core';

try {
  const { code } = transpile(source, { filename: 'style.lass' });
} catch (error) {
  if (error instanceof LassTranspileError) {
    console.error(`${error.category} error at line ${error.location.line}`);
  }
}
```

**Error Categories:**
- `ErrorCategory.SCAN` - Scanner-level errors
- `ErrorCategory.SYMBOL` - Symbol detection errors
- `ErrorCategory.SYNTAX` - Syntax errors

## Features

The Lass transpiler supports the full language feature set:

- **Two-zone model** - Use opening/closing `---` delimiters to define a JS preamble zone followed by a CSS zone
- **Dollar substitution** - `$name` text substitution from preamble variables
- **Expression interpolation** - `{{ expr }}` for inline JavaScript expressions
- **Property lookup** - `@(prop)` to reference previously defined CSS property values
- **Style blocks** - `@{ }` to embed CSS fragments generated from JavaScript
- **Comment stripping** - `//` single-line comments are removed from output

## TypeScript Support

For TypeScript projects using `.lass` files, add type declarations:

```typescript
// lass.d.ts
declare module '*.lass' {
  const css: string;
  export default css;
}
```

## License

MIT
npm package: @lass-lang/vite-plugin-lass
Description: Vite plugin for Lass language
Author: Long-lazuli
Latest version: 0.1.0

# @lass-lang/vite-plugin-lass

Vite plugin for processing `.lass` files. Transforms Lass source to CSS via the `@lass-lang/core` transpiler.

## Installation

```bash
npm install @lass-lang/vite-plugin-lass --save-dev
# or
pnpm add @lass-lang/vite-plugin-lass --save-dev
```

## Usage

Add the plugin to your `vite.config.ts`:

```typescript
import { defineConfig } from 'vite';
import lass from '@lass-lang/vite-plugin-lass';

export default defineConfig({
  plugins: [lass()],
});
```

Then import `.lass` files in your application:

```typescript
import './reset.css';
import './theme.lass';  // Processed by vite-plugin-lass
```

## CSS Modules Support

CSS Modules work automatically with `.module.lass` files:

```typescript
import styles from './component.module.lass';

// Use scoped class names
element.className = styles.container;
```

For TypeScript, add declarations for CSS module imports:

```typescript
// lass.d.ts
declare module '*.lass';

declare module '*.module.lass' {
  const classes: { readonly [key: string]: string };
  export default classes;
}
```

## Options

```typescript
lass({
  verbose: true,  // Enable verbose logging (default: false)
});
```

### verbose

When enabled, logs each `.lass` file as it's loaded:

```
[lass] loaded /path/to/theme.lass
```

## How It Works

1. The plugin intercepts imports of `.lass` files
2. Resolves `.lass` to a virtual `.css` module (e.g., `theme.lass` -> `theme.css`)
3. Transpiles the Lass source to a JavaScript module via `@lass-lang/core`
4. Executes the JS module to extract the CSS string
5. Returns the CSS to Vite's CSS pipeline for standard processing

This approach enables compatibility with Vite's CSS features including CSS Modules, HMR (via Vite's standard CSS handling), and build optimization.

## Peer Dependencies

- `vite` ^5.0.0 || ^6.0.0

## License

MIT
npm package: @lass-lang/vscode-lass-languageservice
Description: Syntax highlighting and language support for Lass - CSS with embedded TypeScript
Author: Lass Language Team
Latest version: 0.0.2

# Lass Language Support for VS Code

Official VS Code extension for the [Lass](https://lass-lang.dev) language — syntax highlighting, bracket matching, and language features for `.lass` files.

## Features

- **Syntax Highlighting** — Full TextMate grammar for `.lass` files with VS Code-quality highlighting
- **Two-Zone Model** — Proper highlighting for the TypeScript preamble (above `---`) and CSS zone (below `---`)
- **Smart Editing** — Auto-closing for Lass symbols: `{{ }}`, `@{ }`, `@( )`
- **Comment Toggling** — `//` line comments (Cmd+/) and `/* */` block comments (Shift+Alt+A)
- **Bracket Matching** — Intelligent matching for CSS braces, JS brackets, and Lass symbols

## What is Lass?

Lass is a CSS authoring language that embeds TypeScript instead of inventing its own programming constructs. Where Sass adds `@mixin` and `@for`, Lass uses real JavaScript/TypeScript — one language to learn, zero new control flow.

Learn more at [lass-lang.dev](https://lass-lang.dev)

## Quick Example

```lass
---
import palette from './palette.json'
const $primary = '#2563eb'
---

.button {
  background: $primary;
}

:root {
  {{ Object.entries(palette).map(([name, value]) => @{
    --{{ name }}: {{ value }};
  }) }}
}
```

**What you'll see:**

- Lines 1-4: TypeScript preamble highlighted between `---` delimiters
- `$primary` highlighted as a Lass variable
- `{{ }}` expressions highlighted as embedded TypeScript
- `@{ }` fragments highlighted as embedded CSS
- Everything else highlighted as standard CSS

## Installation

Install from the VS Code Marketplace:

1. Open VS Code
2. Go to Extensions (Cmd+Shift+X / Ctrl+Shift+X)
3. Search for **"Lass Language Support"**
4. Click **Install**

Or install from the command line:

```bash
code --install-extension lass-lang.vscode-lass
```

## Supported Lass Symbols

| Symbol | Purpose | Auto-close |
|--------|---------|------------|
| `---` | Zone separator (preamble / CSS) | — |
| `$param` | Variable substitution | — |
| `{{ expr }}` | TypeScript expression interpolation | Yes |
| `@{ css }` | CSS fragment block | Yes |
| `@(prop)` | Property lookup accessor | Yes |
| `//` | Single-line comment (stripped from output) | — |

## Requirements

- VS Code 1.80.0 or higher

## Extension Settings

This extension contributes syntax highlighting and language configuration only. No additional settings are required.

## Known Issues

See [GitHub Issues](https://github.com/lass-lang/lass/issues) for known issues and feature requests.

## Release Notes

See [CHANGELOG.md](CHANGELOG.md) for release history.

## Contributing

Contributions are welcome! Visit the [Lass monorepo](https://github.com/lass-lang/lass) to get started.

## License

MIT — See [LICENSE](LICENSE) for details.
npm package: @lasseborly/squegg-sdk
Description: Unofficial SDK for the SQUEGG Smart Hand Grip Trainer.
Author: Lasse Borly
Latest version: 0.1.2

# Squegg SDK




## This is an UNOFFICIAL package and is in no way endorsed or affiliated with the official [SQUEGG Smart Hand Grip Trainer](https://mysquegg.com/) product.

That said it is a great product and can be aquired from [mysquegg.com](https://mysquegg.com/product/squegg-digital-grip-strengthener/) and [Amazon](https://www.amazon.com/SQUEGG-The-Smart-Squeeze-Ball/dp/B07GRS5BXS).

![squegg](https://user-images.githubusercontent.com/2671660/111483768-64421180-8735-11eb-87b7-7a50eba4ed3f.gif)

## [Demo](https://codesandbox.io/s/squeggreact-nf3c5)

## Usage

```sh
$ npm install @lasseborly/squegg-sdk
```

```javascript
import { parseSquegg } from "@lasseborly/squegg-sdk";

/* 
 * Character codes should come from the device itself and it's your job to
 * convert them into an array of numbers. dataViewToArray is a utility function
 * that is useable if you use it on a web platform.
 */

const exampleCharCodes = [49, 57, 49, 49, 57, 46, 54, 50, 55];

parseSquegg(exampleCharCodes);
// { strength: 19.6, isSqueezing: true, batteryCharge: 100 }

```
npm package: @lassehaslev/fit-text
Description: Resizes text to fit width of parent
Author: Lasse S. Haslev
Latest version: 1.1.0

# @lassehaslev/fit-text

> Resizes text to fit width of parent

## Install

Run ```npm install @lassehaslev/fit-text --save``` in your project folder.

## Usage

```js
import FitText from '@lassehaslev/fit-text';
var element = document.querySelector( '.fittext-multiline' );

// Use default options
new FitText( element );

// Overwrite defaults
new FitText( element, {
    compressor: .1,
    minFontSize: Number.NEGATIVE_INFINITY,
    maxFontSize: Number.POSITIVE_INFINITY,
    multiline: false,
    watch: true,
    widthMargin: 0,
    unit: 'em',
    debugColor: null, // Only for debuging
} );
```


## Build Setup

``` bash
# install dependencies
npm install

# serve with hot reload
npm run dev
```
npm package: @lassehaslev/git-status
Description: Run git commands on all recursive folders
Author: Lasse S. Haslev
Latest version: 1.1.1

# @lassehaslev/git-status
> Check `git status` in folder and subfolders.

## Install
``` bash
npm install -g @lassehaslev/git-status
```

## Usage
Just go to a folder and type
``` bash
# Check all git folders in folder
git-status

# Set how deep in subfolders you want to check for git repos
# In this example 2 Folders down (This folder and the next)
git-status --depth=2
```

## Development

```bash
# Install dependencies
npm install

# Link to global npm
npm link
```
npm package: @lassehaslev/laravel-package-template
Description: Create a nice starter template for laravel package
Author: Lasse S. Haslev
Latest version: 1.0.3

# @lassehaslev/laravel-package-template
> Kickstarter for [Laravel package development](https://laravel.com/docs/5.4/packages)

## Install
```bash
npm install -g @lassehaslev/laravel-package-template
```

## Usage
```bash
# Go to the folder you want to create a package

# Option 1: Install all in current folder
laravel-package

# Option 2: Install in other folder
laravel-package my-new-package

# Follow instructions and you are good to go!
```

## Usage in Laravel application
> I use this package together with [LasseHaslev/laravel-modules](https://github.com/LasseHaslev/laravel-modules).
> Follow instructions to use with a laravel application.

1. Install package
`npm install @lassehaslev/laravel-package-template --save-dev`

2. Add script to project `package.json`
```json
{
  "scripts": {
    "package": "laravel-package"
  }
}
```

3. Create package `npm run package Modules/page-name` 
4. Run `composer dump-autoload`
5. Package is ready to use. **Happy Coding!**
npm package: @lassehaslev/restful-vue
Description: Helpers for showing, update and delete elements
Author: Lasse S. Haslev
Latest version: 0.1.5

# @lassehaslev/restful-vue
> Helpers for showing, update and delete elements

## Install
Run ```npm install @lassehaslev/restful-vue --save``` in your project folder

This class contains mixins for making the use of restful apis easier.

We help you to add new items, update items and remove them from index with simple steps.

## Usage
To get any of the mixins just get what you want from the ```@lassehaslev/restful-vue```
``` js
import Vue from 'vue'

// Install plugin and dependencies
import RestfulVue from '@lassehaslev/restful-vue';
Vue.use( RestfulVue );

// Import everything
import { container, create, update, remove } from '@lassehaslev/restful-vue'

// If you only want the container
import { container } from '@lassehaslev/restful-vue'
```

#### Container
The container mixin is to handle list of items and index. This is also where we add newly created models, and remove them on delete.

The container is also the home of the objects that uses the [Create mixin](###Create ) and [Edit mixin](###Edit).
``` html
<template>
    <update v-for="model in models" :url="'/api/update/' + model.id" :model="model"></update>
    <create url="/api/store"></create>
</template>
<script>
    import { container } from '@lassehaslev/restful-vue'
    module.exports = {

        mixins: [ container ],

        components: {
            Create,
            Edit,
        }

    }
</script>
```

#### Create
Create is the mixin thats create an elements an push it in to the container
``` html
<template>
    <button @click="create" class="add">Create</button>
</template>
<script>
    import { create } from '@lassehaslev/restful-vue'
    module.exports = {
        mixins: [ create ],
    }
</script>
```

#### Update and Delete
The update mixin is for updating items. When updated the new items goes into the container index list. 

The Delete sends out that the item should be deleted and it gets removed from the container.
``` html
<template>
    <div>
        <form @submit="update">
            <input id="" type="text" v-model="model.name">
            <button type="submit">Update</button>
        </form>
        <span @click="delete">X</span>
    </div>
</template>
<script>
    import { update, remove } from '@lassehaslev/restful-vue'
    module.exports = {
        mixins: [ update, remove ],
    }
</script>
```

## Development
``` bash
# install dependencies
npm install

# serve with hot reload at localhost:8080
npm run dev
```
npm package: @lassehaslev/templater
Description: Create a nice starter template for laravel package
Author: Lasse S. Haslev
Latest version: 0.2.3

# @lassehaslev/templater
> CLI (Command Line Interface) template engine for all sorts of files

## Install
```bash
npm install @lassehaslev/templater --save
```

## Usage
Templater takes 2 parameters
1. [Inquirer.js objects](https://github.com/sboudrias/Inquirer.js#objects) (Array)
2. Options (Object)
    - ```templateFolder``` default:```__dirname + '/../templates'```
        - What folder to find templates
    - ```folder``` default:```process.argv[2] || './'```
        - Where to add new templates

```js
#! /usr/bin/env node

var Templater = require( '@lassehaslev/templater' );
var templater = new Templater([
    {
        type: 'input',
        name: 'author.name',
        message: 'Whats your name?',
        default: 'My name',
    },
    {
        type: 'input',
        name: 'author.email',
        message: 'Whats your email?',
        default: 'your@email.com',
    },
], {
    templateFolder: __dirname + '/../templates',
});

templater.start().then( function( response ) {
    console.log( 'All complete'! );
} );
```

#### Templates
You can add any files in this folder. All files and folders/subfolders added in this folder will be copied to destination and rendered with new variables.

Use ```<% variable.name %>``` syntax to edit your variables.

###### Example file
```php
<?php

/**
 * Class TestFile
 * @author <% author.name %> <<% author.email %>>
 */
class TestFile
{
}
```

*This will render*
```php
<?php

/**
 * Class TestFile
 * @author My name <your@email.com>
 */
class TestFile
{
}
```