open-index/open-npm huggingface dataset:
npm package: @kikopalomares/is-audio
Description: Check if a filepath is an audio file
Author: Kiko Palomares
Latest version: 0.1.0

# is-audio
Check if a file path is an audio file

## Install

```
$ npm i @kikopalomares/is-audio
```


## Usage

```js
const isAudio = require('@kikopalomares/is-audio');

isAudio('src/yourFile.mp3');
//=> true

isAudio('src/yourFile.txt');
//=> false
```

## License

MIT © [Kiko Palomares](https://kikopalomares.com)
npm package: @kikuchan/binary-reader
Description: binary-reader
Author: kikuchan
Latest version: 0.1.0-alpha.7

# @kikuchan/binary-reader

Small binary buffer reader for streaming-style, cursor-based parsing in Node.js and browsers.

## Install

```bash
npm install -D @kikuchan/binary-reader
```

## Quick Start

```ts
import { BinaryReader } from '@kikuchan/binary-reader';

const u8 = new Uint8Array([0x12, 0x34, 0x89, 0xab, 0xcd, 0xef]);
const r = new BinaryReader(u8); // default: big-endian

r.readUint16();     // 0x1234 (BE)
r.readUint32();     // 0x89ABCDEF (BE)

// Force endian per read
r.seek(0);
r.readUint16le();   // 0x3412

// Strings
const s = new BinaryReader(new TextEncoder().encode('Hi\0A'));
s.readString();     // 'Hi' (C-string, consumes trailing NUL)
s.readUint8();      // 0x41 ('A')

// Raw bytes
const r2 = new BinaryReader(new Uint8Array([1,2,3,4]));
const bytes = r2.peekBytes(2); // Uint8Array [1,2], does not advance
const next  = r2.readBytes(3); // Uint8Array [1,2,3], advances by 3
```

## API

- Position/state:
  - `position`, `size`, `remain`, `eof()`
  - `seek(n | label)`, `bookmark(label)`, `rewind()`, `skip(n?)`, `align(n)`

- Unsigned integers:
  - Base: `readUint8()`, `readUint16(le?)`, `readUint32(le?)`, `readUint64(le?)`
  - Suffix aliases: `readUint16le/be()`, `readUint32le/be()`, `readUint64le/be()`

- Signed integers:
  - Base: `readInt8()`, `readInt16(le?)`, `readInt32(le?)`, `readInt64(le?)`
  - Suffix aliases: `readInt16le/be()`, `readInt32le/be()`, `readInt64le/be()`

- Floating-point:
  - Base: `readFloat16(le?)`, `readFloat32(le?)`, `readFloat64(le?)`
  - Suffix aliases: `readFloat16le/be()`, `readFloat32le/be()`, `readFloat64le/be()`

- Bytes and strings:
  - `peekBytes(n?) -> Uint8Array` — peek without advancing (default: all remaining)
  - `readBytes(n?) -> Uint8Array` — read bytes and advance (default: all remaining)
  - `readString(len?, encoding?) -> string | undefined`
    - `len` omitted: C-string (null-terminated). Missing terminator returns `undefined` and does not advance.
    - `len` provided: reads exactly `len` bytes; decode failure returns `undefined` and does not advance.

## Endianness

- Default endianness is big-endian.
- You can set a default via constructor: `new BinaryReader(u8, { littleEndian: true })`.
- Per-call overrides use either the second param (e.g. `readUint16(true)`) or the `le/be` suffix methods.

## Notes

- Streaming-focused: the API models a moving cursor over a buffer. Methods read at the cursor and advance.
- `seek()` and `skip()` clamp positions to `[0, size]`.
npm package: @kikuchan/binary-writer
Description: binary-writer
Author: kikuchan
Latest version: 0.1.0-alpha.6

# @kikuchan/binary-writer

Small binary buffer writer for streaming-style, cursor-based encoding in Node.js and browsers.

## Install

```bash
npm install -D @kikuchan/binary-writer
```

## Quick Start

```ts
import { BinaryWriter } from '@kikuchan/binary-writer';

// Resizable by default, big-endian default
const w = new BinaryWriter()
  .writeUint16(0x1234)                   // BE
  .writeUint32le(0x89abcdef)
  .writeUint64be(0x0102030405060708n)
  .bookmark('sizeHere')                  // movement methods are chainable too
  .align(4);

const out = new Uint8Array(w.buffer);
```

## API

- Position/state:
  - `position`, `size`, `capacity`, `remain`
  - `seek(n | label)`, `bookmark(label)`, `rewind()`, `advance(n)`, `align(n)`

- Unsigned integers:
  - Base: `writeUint8(v)`, `writeUint16(v, le?)`, `writeUint32(v, le?)`, `writeUint64(v, le?)`
  - Suffix aliases: `writeUint16le/be(v)`, `writeUint32le/be(v)`, `writeUint64le/be(v)`

- Signed integers:
  - Base: `writeInt8(v)`, `writeInt16(v, le?)`, `writeInt32(v, le?)`, `writeInt64(v, le?)`
  - Suffix aliases: `writeInt16le/be(v)`, `writeInt32le/be(v)`, `writeInt64le/be(v)`

- Floating-point:
  - Base: `writeFloat16(v, le?)`, `writeFloat32(v, le?)`, `writeFloat64(v, le?)`
  - Suffix aliases: `writeFloat16le/be(v)`, `writeFloat32le/be(v)`, `writeFloat64le/be(v)`

- Bytes and strings:
  - `writeBytes(data)` — accepts `Uint8Array`/`Uint8ClampedArray`/`ArrayBuffer`/`DataView`
  - `writeString(str, { cstring?: boolean, fixedLength?: number, callback? })`

### Chainability

- All movement and write methods return the writer instance for chaining:
  - Movement: `seek`, `bookmark`, `rewind`, `advance`, `align`
  - Writes: all `write*` numeric methods, `writeBytes`, and `writeString`

## Endianness

- Default is big-endian.
- You can change the default per instance: `new BinaryWriter(sizeOrBuffer?, { littleEndian: true })`.
- Override per-call with the second parameter or use the `le/be` suffix methods.

## Notes

- Streaming-focused: the API models a moving cursor over a buffer. Methods write at the cursor and advance.
- By default, instances are resizable and grow automatically.
npm package: @kikuchan/hexdump
Description: hexdump
Author: kikuchan
Latest version: 0.1.0-alpha.10

# @kikuchan/hexdump

Tiny, configurable hex dump utility for Node.js and browsers.

## Install

```bash
npm install -D @kikuchan/hexdump
```

## Usage

```ts
import { hexdump } from '@kikuchan/hexdump';

const bytes = Uint8Array.from([
  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
]);

hexdump.log(bytes);
```

output:

```
00000000:  00 01 02 03 04 05 06 07  08 09 0a 0b 0c 0d 0e 0f  |................|
00000010:                                                    |                |
```

## API

### Basic Functions

- `hexdump.log|warn|error(data, options?)`: outputs to `console.log|warn|error` respectively.
- `hexdump(data, options?)`: returns the full string instead of printing.
- `hexdump.create(printer)`: returns a hexdump function that prints to `printer` (a function that takes a string).

### `data`
- Binary-like data: `Uint8Array`, `Uint8ClampedArray`, `ArrayBufferLike` or `DataView`;

### `options?`
- `addrOffset: number` — Starting address for the first byte. Default `0`.
- `addrLength: number` — Hex digits shown for the address. Default `8 - prefix.length` (clamped to `>= 0`).
- `prefix: string` — Printed before the address (e.g. `"0x"`). Default `""`.
- `foldSize: number` — Bytes per row. Default `16`.
- `printChars: boolean` — Show the ASCII gutter at right. Default `true`.
- `footer: boolean` — Print a trailing line showing the next address. Default `true`.
- `color: boolean | 'simple' | 'html' | ((s: string, ctx: Context) => ColorizerOperation | undefined)` —
  - `true` or `'simple'`: add ANSI colors in terminals.
  - `'html'`: wrap parts with semantic spans like `hexdump-address`, `hexdump-ascii`, etc., and escape content.
- `printer?: (line: string) => void | null` — Provide a per-line sink directly in options. Set to `null` to disable printing even if a default printer is configured.
- `formatter: (s: string, ctx: Context) => string | undefined` — Transform each fragment before it is appended. Return `undefined` to drop that fragment.
npm package: @kikuchan/string-reader
Description: string-reader
Author: kikuchan
Latest version: 0.1.0-alpha.8

# @kikuchan/string-reader

Lightweight sequential string reader with simple matching helpers.

## Install

```bash
npm install -D @kikuchan/string-reader
```

## Quick Start

```ts
import { StringReader } from '@kikuchan/string-reader';

const r = new StringReader('key=value;rest');
r.read(3);                // 'key'
r.match('=');             // advances
const val = r.readUntil(';'); // 'value'

r.rewind();
r.startsWith('key');      // ['key'] (does not advance)
```

## API

- Position/state:
  - `position`, `size`, `remain`, `eof()`
  - `seek(n)`, `skip(n?)` (both clamp to range 0..size)

- Matching:
  - `startsWith(string | RegExp) -> string[] | null` (anchored at current position; does not advance)
  - `match(string | RegExp, translate?) -> T | string[] | null` (advances on match)
  - `search(string | RegExp, translate?) -> { skipped, matched } | T | null` (advances to end of match when found)
  - `skipUntil(string | RegExp) -> boolean` (advances to start of match when found)
  - `readUntil(string | RegExp) -> string | null` (reads up to but not including match; does not consume match)

- Reading:
  - `read(n?: number) -> string`
    - Defaults to 1 char; requires `n > 0` (throws `RangeError` otherwise).
    - Clamps at end-of-string; returns empty string at EOF.

## Notes

- `RegExp` behavior: `startsWith` is anchored (sticky-like), while `search`/`readUntil` scan forward.
npm package: @kilamieaz/dashboard-layouts
Description: Core generator, scaffolder, and UI primitives for ATAMS dashboard applications
Latest version: 1.0.0

# @kilamieaz/dashboard-layouts

Core generator, scaffolder, and UI library for ATAMS dashboard applications.

## Install

```bash
# pin to a specific version tag
npm install github:kilamieaz/dashboard-layouts#v0.1.0

# or always latest
npm install github:kilamieaz/dashboard-layouts
```

## Usage

```ts
import { generateModule } from "@kilamieaz/dashboard-layouts/lib/generator";
import { OpenAPIParser } from "@kilamieaz/dashboard-layouts/cli/openapi-parser";
```

## Versioning

Versions are tracked via git tags (`v0.1.0`, `v0.2.0`, ...).  
Check [Releases](https://github.com/kilamieaz/dashboard-layouts/releases) for changelog.

## Releasing a new version

1. Update `version` in `package.json`
2. Push to `main` — GitHub Actions will auto-build `dist/`, commit it, create tag & GitHub Release

Or manually:
```bash
bun run release
```
npm package: @kilamieaz/dashboard-ui
Description: Radix UI + Tailwind component library for ATAMS dashboard applications
Latest version: 1.0.2

# @kilamieaz/dashboard-ui

Radix UI + Tailwind component library for ATAMS dashboard applications.

## Install

```bash
# pin to a specific version tag
npm install github:kilamieaz/dashboard-ui#v0.1.0

# or always latest
npm install github:kilamieaz/dashboard-ui
```

## Usage

```tsx
import { Button, Input, Dialog } from "@kilamieaz/dashboard-ui";
```

## Versioning

Versions are tracked via git tags (`v0.1.0`, `v0.2.0`, ...).  
Check [Releases](https://github.com/kilamieaz/dashboard-ui/releases) for changelog.

## Releasing a new version

1. Update `version` in `package.json`
2. Push to `main` — GitHub Actions will auto-build `dist/`, commit it, create tag & GitHub Release

Or manually:
```bash
bun run release
```
npm package: @kilann/guid-generator
Description: A utility to generate sortable and unique Comb GUIDs
Author: Olivier Belleval
Latest version: 1.3.4

# GUID_generator

A utility to generate Comb GUIDs

## Installation

```bash
npm install @kilann/guid-generator
yarn add @kilann/guid-generator
pnpm add @kilann/guid-generator
```

## Why ?

This package is a simple utility to generate Comb GUIDs. 
A Comb GUID is a GUID that is generated from a timestamp and a UUID.

It make it sortable and unique.

You can pass in a prefix and/or suffix to the function, this will help you to identify the Comb GUID.

Fully without dependencies.

## Usage

```ts
import { GUIDGenerator } from "@kilann/guid-generator";

const guid = GUIDGenerator();
console.log("guid:",  guid);
// guid: 17e8e42f-02b9-4086-a4d8-30285f1819df


// you can also pass in a prefix and/or suffix
const pre_su_guid = GUIDGenerator("prefix", "suffix");
console.log("pre_su_guid:", pre_su_guid);
//pre_su_guid: prefix-17e8e42f-0354-48bb-a886-90c376d207bb-suffix
```

On the same way, you can create UUIDs

```ts
import { UUIDGenerator } from "@kilann/guid-generator";

const uuid = UUIDGenerator();
console.log("uuid:",  uuid);
// uuid: 1e6129ba-2200-4fe8-9f77-1e862279d5b7

const pre_su_uuid = UUIDGenerator("prefix", "suffix");
console.log("pre_su_uuid:", pre_su_uuid);
// pre_su_uuid: prefix-fad2ece1-72f8-4ff2-89ec-efa344c3d9fc-suffix
```

## License

MIT
npm package: @kilbergr/dto-builder
Description: Data only object builder from a typescript interface
Author: Kilbergr
Latest version: 0.2.0-Dev.5

# DTO Builder

Build a DTo object from an interface.

## Installation

**NPM**

```bash
npm install @kilbergr/dto-builder
```

**Yarn**

```bash
yarn add @kilbergr/dto-builder
```

## Usage

```typescript
import { DtoBuilder } from '@kilbergr/dto-builder';
```

## Examples

### Build a simple DTO

```typescript
import { isRight } from 'fp-ts/Either';
import { DtoBuilder } from '@kilbergr/dto-builder';

interface User {
  id: number;
  name: string;
  email: string;
  tags: string[];
}

const builder = DtoBuilder.create<User>();

const user = builder
  .setId(1)
  .setName('John Doe')
  .setEmail('john.doe@example.com')
  .addTags('tag1', 'tag2')
  .build();

if (isRight(user)) {
  console.log(user.right);
} else {
  console.log('Building user failed', user.left);
}
```

### Patching a DTO

Override a fragment of the DTO.

```typescript
import { DtoBuilder } from '@kilbergr/dto-builder';

interface User {
  id: number;
  name: string;
  email: string;
}

const builder = DtoBuilder.create<User>();

const userBuilder = builder
  .setId(1)
  .setName('John Doe')
  .setEmail('john.doe@example.com');

userBuilder.patch({
  name: 'Jane Doe',
  email: 'jane.doe@example.com',
});
```

### Cloning a DTO builder

Share a common data between multiple DTOs.

```typescript
import { DtoBuilder.create } from '@kilbergr/dto-builder';

interface User {
  id: number;
  name: string;
  email: string;
  organization: string;
}

const userBuilder = DtoBuilder.create<User>().setOrganization('Test Inc.');
const userOne = userBuilder
  .clone()
  .setId(1)
  .setName('John Doe')
  .setEmail('john.doe@example.com')
  .build();

const userTwo = userBuilder
  .clone()
  .setId(2)
  .setName('Jane Doe')
  .setEmail('jane.doe@example.com')
  .build();
```

### Counting arrays

```typescript
import { DtoBuilder.create } from '@kilbergr/dto-builder';

interface WithTags {
  tags: string[];
}

const builder = DtoBuilder.create<WithTags>().addTags('tag1', 'tag2', 'tag3');

const tagsCount = builder.countTags();
```

### Validating DTO

The DTO builder can validate the DTO before building it. It requires some
validation function for that. It is possible to use for example some json schema
with ajv.

```typescript
import { Ajv } from 'ajv';
import { DtoBuilder.create } from '@kilbergr/dto-builder';

const ajv = new Ajv();


interface UserDto {
  id: number;
  name: string;
  email: string;
}

const userSchema: JsonSchemaType<UserDto> = { ... };

const userDtoValidator = ajv.compile(userSchema);

function validateUserDto(dto: UserDto): boolean {
  if (!userDtoValidator(dto)) {
    const errors = userDtoValidator.errors;

    const error = ... // aggregate errors into one`

    return error;
  };
  return true;
}

const userBuilder = DtoBuilder.create<UserDto, UserBuilderError>({}, {
  validate: validateUserDto
});

const user = userBuilder.setId(1).build();

if (isRight(user)) {
  console.log(user.right);
} else {
  console.log('Building user failed', user.left);
}
```
npm package: @kilbergr/is-bigint
Description: IsBigint is an workaround for the lack of IsBigInt decorator in class-validator
Author: Kilbergr
Latest version: 0.1.0-Dev.7

# IsBigint

This a temporary fix for missing `@IsBigint` decorator from `class-validator` package.

The decorator works the same ways as the `@IsNumber` decorator from the same package.

This package becomes obsolete when the `@IsBigint` decorator is added to the `class-validator` package.

Please follow this [pull request](https://github.com/typestack/class-validator/pull/2506) on the `class-validator` repository.

### Installation

```bash
npm install @kilbergr/is-bigint class-validator
```

### Usage

```typescript
import { IsBigint } from '@kilbergr/is-bigint';

class MyClass {
  @IsBigint()
  myField: bigint;
}
```
npm package: @kilbergr/tagged-types
Description: Opaque types library
Author: Kilbergr
Latest version: 0.1.0-Alpha.5

# Tagged types

The library implements various string sub-type helpers. They might be useful for
cases when we want type safety for emails, URLs, BICs, IBANs or other string types.
Each subtype module exposes the type and a set of basic functions to work with it,
like `cast`, `isTypeof` and `assert`.

The package is organized into submodules, each can be imported separately.

### Installation

**npm**

```bash
npm install @kilbergr/tagged-types
```

**yarn**

```bash
yarn add @kilbergr/tagged-types
```

### Importing

```typescript
import { BIC, type bic } from '@kilbergr/tagged-types/bic';
import { Email, type email } from '@kilbergr/tagged-types/email';
```

### Usage

```typescript
// Use the type in your code
let myBic: bic;
let myEmail: email;

// Cast a string to the type
myBic = BIC('DEUTDEFF500');
myEmail = Email('john.doe@example.com');

// Check if a string is of the type
if (BIC.isTypeof(myBic)) {
  ...
}

if (Email.isTypeof(myEmail)) {
  ...
}

// Assert a string is of the type
BIC.assert(myBic);
Email.assert(myEmail);

```

Some string sub-types compose multiple information and implement `parse` and
`from` functions to work with them.

```typescript
const { bankCode, branchCode, locationCode, countryCode } = BIC.parse(myBic);
```