open-index/open-npm huggingface dataset:
npm package: @philipp-seiko/headlessui
Description: A set of completely unstyled, fully accessible UI components for React, designed to integrate beautifully with Tailwind CSS.
Latest version: 1.7.19

<h3 align="center">
  @headlessui/react
</h3>

<p align="center">
  A set of completely unstyled, fully accessible UI components for React, designed to integrate
  beautifully with Tailwind CSS.
</p>

<p align="center">
  <a href="https://www.npmjs.com/package/@headlessui/react"><img src="https://img.shields.io/npm/dt/@headlessui/react.svg" alt="Total Downloads"></a>
  <a href="https://github.com/tailwindlabs/headlessui/releases"><img src="https://img.shields.io/npm/v/@headlessui/react.svg" alt="Latest Release"></a>
  <a href="https://github.com/tailwindlabs/headlessui/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@headlessui/react.svg" alt="License"></a>
</p>

## Installation

```sh
npm install @headlessui/react
```

## Documentation

For full documentation, visit [headlessui.dev](https://headlessui.dev/react/menu).

## Community

For help, discussion about best practices, or any other conversation that would benefit from being searchable:

[Discuss Headless UI on GitHub](https://github.com/tailwindlabs/headlessui/discussions)

For casual chit-chat with others using the library:

[Join the Tailwind CSS Discord Server](https://discord.gg/7NF8GNe)
npm package: @philipp122/totype
Description: A better alternative to the typeof-operator in JS. Utilizes the internal [[CLASS]] property.
Author: Philipp Steckenbauer
Latest version: 1.0.1

# toType
A better alternative to the typeof-operator in JS. Utilizes the internal [[CLASS]] property.

The function toType is designed as an alternative to the built in typeof operator and takes one argument and returns a string. 
It utilizes the internal [[CLASS]] property of Javascript Objects. See the following code for comparison:

```javascript
typeof undefined;                           //"undefined"
typeof null;                                //"object"
typeof true;                                //"boolean"
typeof 123;                                 //"number"
typeof "Hello World!";                      //"string"
typeof {a: 4};                              //"object"
typeof [1, 2, 3];                           //"object"
(() => {console.log(typeof arguments)})();  //"object"
typeof new ReferenceError;                  //"object"
typeof new Date;                            //"object"
typeof /a-z/;                               //"object"
typeof Math;                                //"object"
typeof JSON;                                //"object"
typeof new Boolean(true);                   //"object"
typeof new Number(4);                       //"object"
typeof new String("abc");                   //"object"
```

```javascript
toType(undefined);                          //"undefined"
toType(null);                               //"null"
toType(true);                               //"boolean"
toType(123);                                //"number"
toType("Hello World!");                     //"string"
toType({a: 4});                             //"object"
toType([1, 2, 3]);                          //"array"
(() => {console.log(toType(arguments))})(); //"arguments"
toType(new ReferenceError);                 //"error"
toType(new Date);                           //"date"
toType(/a-z/);                              //"regexp"
toType(Math);                               //"math"
toType(JSON);                               //"json"
toType(new Boolean(true));                  //"boolean"
toType(new Number(4));                      //"number"
toType(new String("abc"));                  //"string"
```

As you can see, there is a vast difference between the built-in typeof operator and the new toType function when it comes to more specific type checking, like regular expressions, built-in objects, error objects or even arrays.
npm package: @philipp122/type
Description: Better Type Checking
Author: Philipp Steckenbauer
Latest version: 1.1.1

# Type

This Project adds better type checking from basic JS types.

## Installation

```
npm install --save @philipp122/type
```

## Usage:

Type supports 14 primitive JS Types: Undefined, Null, Boolean, Number, NaN, Infinity, String, Symbol, Array, Object, WeakSet, Set, WeakMap and Map as well as 2 aliases of Number: Integer and Float.

Any value can be checked against those types:

```javascript
const Type = require('@philipp122/type');

// ALL of the following return true
console.log(undefined instanceof Type.Undefined);
console.log(null instanceof Type.Null);
console.log(true instanceof Type.Boolean);
console.log(5 instanceof Type.Number);
console.log(5 instanceof Type.Integer);
console.log(5.5 instanceof Type.Number);
console.log(5.5 instanceof Type.Float);
console.log(Infinity instanceof Type.Infinity);
console.log(NaN instanceof Type.NaN);
console.log("Hello World" instanceof Type.String);
console.log(Symbol("Bye") instanceof Type.Symbol);
console.log([1, 2, 3] instanceof Type.Array);
console.log({a: 1, b: 2} instanceof Type.Object);
console.log(new WeakSet() instanceof Type.WeakSet);
console.log(new Set() instanceof Type.Set);
console.log(new WeakMap() instanceof Type.WeakMap);
console.log(new Map() instanceof Type.Map);
```

See index.test.js for more examples.
npm package: @philippdormann/appledevices
Description: npm package for parsing apple device code names to readable device names
Author: Philipp Dormann
Latest version: 1.0.1

# @philippdormann/appledevices
npm package for parsing apple device code names to readable device names

## Data Source
https://gist.github.com/adamawolf/3048717

## Library Usage
```
pnpm i @philippdormann/appledevices
```
```
import { getDeviceNameByIdentifier } from "@philippdormann/appledevices"

console.log(getDeviceNameByIdentifier("iPhone15,3"));
```
## Build (pnpm monorepo)
```
pnpm build
```
npm package: @philippdormann/elternportal-api
Description: unofficial art soft and more Elternportal-API
Latest version: 2.11.0

# ElternPortal API Client 📚

This library provides an easy-to-use interface for interacting with the ElternPortal system, a platform for school-parent communication in Germany.

## Features 🌟

- **Authentication**: Securely log in to the ElternPortal system
- **Kid Management**: Set and retrieve information about children linked to the account
- **School Information**: Fetch various details about the school
- **Announcements**: Get updates from the school's bulletin board (Schwarzes Brett)
- **Calendar**: Retrieve school events and schedules
- **Parent Letters**: Access and download parent letters (Elternbriefe)
- **Lost and Found**: View items in the lost and found section

## Installation 💻

```bash
pnpm i @philippdormann/elternportal-api
```

## Usage 🚀

### Initializing the Client

```typescript
import { getElternportalClient } from "@philippdormann/elternportal-api";

const client = await getElternportalClient({
  short: "schoolcode",
  username: "your_username",
  password: "your_password",
  kidId: 0, // Optional
});
```

### Available Methods

#### Get Kids 👨‍👩‍👧‍👦

```typescript
const kids = await client.getKids();
```

#### Get School Information 🏫

```typescript
const schoolInfo = await client.getSchoolInfos();
```

#### Get Bulletin Board (Schwarzes Brett) 📌

```typescript
const posts = await client.getSchwarzesBrett(includeArchived);
```

#### Get School Calendar (Termine) 📅

```typescript
const events = await client.getTermine(fromDate, toDate);
```

#### Get Timetable 🕒

```typescript
const timetable = await client.getStundenplan();
```

#### Get Lost and Found Items 🧦

```typescript
const lostItems = await client.getFundsachen();
```

#### Get Parent Letters 📬

```typescript
const letters = await client.getElternbriefe();
```

#### Download Files 📁

```typescript
const bulletinFile = await client.getSchwarzesBrettFile(fileId);
const letterFile = await client.getElternbrief(letterId);
```

#### Get exam schedule

```typescript
const examSchedule = await client.getSchulaufgabenplan();
```

## Types 📝

The library includes TypeScript definitions for various data structures:

- `SchoolInfo`
- `Termin` (Calendar Event)
- `Elternbrief` (Parent Letter)
- `SchwarzesBrettBox` (Bulletin Board Item)
- `ElternportalFile`
npm package: @philippdormann/fints
Description: FinTS client library
Latest version: 0.5.0

# FinTS Node.js Client

A client library for communicating with [FinTS servers](https://www.hbci-zka.de/).

## Example

```typescript
import { PinTanClient } from "fints";

const startDate = new Date("2018-08-10T12:00:00Z");
const endDate = new Date("2018-10-10T12:00:00Z");

const client = new PinTanClient({
    url: "https://example.com/fints",
    name: "username",
    pin: 12345,
    blz: 12345678,
});

const accounts = await client.accounts();
console.info(accounts); // List of all accounts.

const statements = await client.statements(accounts[0], startDate, endDate);
console.info(statements); // List of all statements with transactions in specified date range.
```

[Further code examples](README_advanced_usage.md)

## Features

- Load list of accounts.
- Load list of statements and transactions in specified range.
- Parse statement [MT940](https://en.wikipedia.org/wiki/MT940) format.
- Parse transaction descriptions.
- Extract [reference tags](https://www.dzbank.de/content/dam/dzbank_de/de/home/produkte_services/Firmenkunden/PDF-Dokumente/transaction%20banking/elektronicBanking/SEPA-Belegungsregeln_MT940-DK_082016.~644b217ec96b35dfffcaf18dc2df800a.pdf) from transactions.
- List supported TAN methods.
- Parse basic metadata.

## Missing

- Get current balance.
- List holdings.
- Initiate any kind of SEPA transfers or debits.

## Resources

- [API Reference](https://prior99.gitlab.io/fints)
- [Official specification](https://www.hbci-zka.de/spec/3_0.htm)
- [Database of banks with their URLs](https://github.com/jhermsmeier/fints-institute-db)

## Credits + About
Big thanks to <https://github.com/Prior99/fints> for the initial implementation.

I needed to apply some fixes and simplifications - this fork is by no means supported or a stable implementation
npm package: @philippdormann/gulp-sass
Description: Gulp plugin for sass
Author: Philipp Dormann
Latest version: 5.0.5

# @philippdormann/gulp-sass
Sass plugin for [Gulp](https://github.com/gulpjs/gulp).

# Support
Ported to Node.js >= 16

# Install
```
yarn add -D @philippdormann/gulp-sass
```

# Basic Usage
Something like this will compile your Sass files:

```javascript
const gulp = require('gulp');
const sass = require('@philippdormann/gulp-sass');

sass.compiler = require('node-sass');

gulp.task('sass', function () {
  return gulp.src('./sass/**/*.scss')
    .pipe(sass())
    .pipe(gulp.dest('./css'));
});

gulp.task('sass:watch', function () {
  gulp.watch('./sass/**/*.scss', ['sass']);
});
```
npm package: @philippdormann/mobiledevices
Description: npm package for parsing mobile device code names to readable device infos
Author: Philipp Dormann
Latest version: 1.0.1

# @philippdormann/mobiledevices
npm package for parsing mobile device code names to readable device infos

## Library Usage
### Install
```
pnpm i @philippdormann/mobiledevices
```
## Usage
```
import { getDeviceInfoByIdentifier } from "@philippdormann/mobiledevices"

console.log(getDeviceInfoByIdentifier("iPhone15,3"));
console.log(getDeviceInfoByIdentifier("LG-H815"));
console.log(getDeviceInfoByIdentifier("GM1913"));
console.log(getDeviceInfoByIdentifier("iPhone11,8"));
```
## Result
```
{ brand: 'Apple', name: 'iPhone 14 Pro Max', device: 'iPhone 14 Pro Max', model: 'iPhone15,3' }
{ brand: 'LGE', name: 'LG G4', device: 'p1', model: 'LG-H815' }
{ brand: 'OnePlus', name: 'OnePlus 7 Pro', device: 'OnePlus7Pro', model: 'GM1913' }
{ brand: 'Apple', name: 'iPhone XR', device: 'iPhone XR', model: 'iPhone11,8' }
```
## StackBlitz Example Code
https://stackblitz.com/edit/vitejs-vite-levycs?file=main.js