open-index/open-npm huggingface dataset:
npm package: @maple3142/pandoc-bin-linux-amd64
Description: linux amd64 pandoc binary from https://github.com/jgm/pandoc/releases
Latest version: 3.6.2

linux amd64 pandoc binary from https://github.com/jgm/pandoc/releases

https://www.npmjs.com/@maple3142/pandoc-bin-linux-amd64
npm package: @mapleafgo/next-less
Description: Next.js v9.3+ Less Support
Author: mapleafgo
Latest version: 0.0.1

# Next.js v9.3+ Less Support

Use the latest official support for sass to support less

```bash
npm i @mapleafgo/next-less less
# or
yarn add @mapleafgo/next-less less
```

## Usage

Create a next.config.js in your project

```javascript
// next.config.js
const withLess = require("@mapleafgo/next-less");
module.exports = withLess(
  {
    /* less-loader lessOptions */
  },
  {
    /* config options here */
  }
);
```

Same as official sass, You can use component-level Less via CSS Modules and the `.module.less` extension.
npm package: @mapleflow/mcp-server
Description: MCP server for MapleFlow — exposes AI, utility, and verify endpoints as tools
Author: MapleFlow
Latest version: 0.10.0

# @mapleflow/mcp-server

MCP (Model Context Protocol) server for [MapleFlow](https://mapleflow.io).

**Spec-driven** — fetches `/openapi.json` at startup and auto-registers every endpoint as a tool. When you add or change API endpoints, just update the OpenAPI spec. Zero MCP code changes needed.

## Install

```bash
npm install -g @mapleflow/mcp-server
```

## Configure

### Claude Desktop / Claude Code

```json
{
  "mcpServers": {
    "mapleflow": {
      "command": "npx",
      "args": ["-y", "@mapleflow/mcp-server"],
      "env": {
        "MAPLEFLOW_API_KEY": "sk_live_..."
      }
    }
  }
}
```

### Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `MAPLEFLOW_API_KEY` | Yes | Your MapleFlow API key |
| `MAPLEFLOW_BASE_URL` | No | Custom base URL (default: `https://mapleflow.io`) |

## How It Works

On startup, the server:
1. Fetches the OpenAPI spec from `{BASE_URL}/openapi.json`
2. Converts each operation into an MCP tool with proper schemas
3. Routes tool calls to the corresponding API endpoint

New endpoints appear as tools automatically — no code changes, no rebuilds.

## Get an API Key

Sign up at [mapleflow.io/signup](https://mapleflow.io/signup) — 500 free credits included.

## License

MIT
npm package: @mapleflow/sdk
Description: Official TypeScript SDK for the MapleFlow API platform — auto-generated from OpenAPI spec
Author: MapleFlow
Latest version: 0.10.0

# @mapleflow/sdk

Official TypeScript SDK for the [MapleFlow](https://mapleflow.io) API platform. Auto-generated from OpenAPI spec using [Hey API](https://heyapi.dev/).

## Install

```bash
npm install @mapleflow/sdk
```

## Quick Start

```typescript
import { createClient } from "@mapleflow/sdk";
import { postAiChat, getWeather, postTranslate, getAccount } from "@mapleflow/sdk";

const client = createClient({
  baseUrl: "https://mapleflow.io",
  headers: { "X-API-Key": "sk_live_..." },
});

// AI Chat (2 credits)
const chat = await postAiChat({
  client,
  body: {
    messages: [{ role: "user", content: "What is the capital of France?" }],
    model: "fast",
  },
});

// Translate (1 credit)
const translation = await postTranslate({
  client,
  body: { text: "Hello!", to: "es" },
});

// Weather (1 credit)
const weather = await getWeather({
  client,
  query: { location: "Toronto" },
});

// Check balance
const account = await getAccount({ client });
```

## Regenerate SDK

```bash
npm run generate
```

This reads `../../src/openapi.json` and regenerates all types + SDK functions.

## License

MIT
npm package: @maplelabs/hardhat-scripts
Description: Hardhat Ethereum Scripts used at Maple Labs
Author: Chad Lynch
Latest version: 1.2.1

# Hardhat Scripts

Maple labs uses these deployment scripts for hardhat ethereum packages. These scripts were inspired by and made for <a href="https://github.com/austintgriffith/scaffold-eth">Scaffold Eth!</a>

## scripts/deploy.js

```javascript
const { deploy } = require("@maplelabs/hardhat-scripts");

async function main() {
  const bCreator = await deploy("MyContract", [param1, param2]);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

## scripts/publish.js

```javascript
const { publish } = require("@maplelabs/hardhat-scripts");

async function main() {
  const directories = [
    "../web-app/src/contracts",
    "../contracts/src/contracts",
  ];
  publish(directories);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```
npm package: @mapleleaf1234/vue_comp
Description: 关于vue的后台管理组件
Author: mapleleaf1234
Latest version: 1.1.19

# comp

> 基于vue的后台管理组件

## Build Setup

```
// 安装@mapleleaf1234/vue_comp
npm i -D @mapleleaf1234/vue_comp

// 在主入口main.js里边
import vue_comp from '@mapleleaf1234/vue_comp'
Vue.use(vue_comp);

```
npm package: @maplero/prettier-config
Description: prettier config used by spa in maple
Author: liutsing
Latest version: 0.0.2

# `@maplero/prettier-config`

> eslint config used by react app in Maple

## Usage

```bash
npm install @maplero/prettier-config -D
```
```bash
pnpm install @maplero/prettier-config -D
```
```bash
yarn add @maplero/prettier-config -D
```

### method1
add `prettier` field in `package.json`

```json
{
  "prettier": "@maplero/prettier-config"
}
```
### method2
create `.prettierrc.js` with next content

```js
module.exports = {
  ...require("@maplero/prettier-config"),
};
```
npm package: @mapleswap/sdk
Description: 🛠 An SDK for building applications on top of Uniswap.
Latest version: 3.0.6

# Uniswap SDK

[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
[![Actions Status](https://github.com/Uniswap/uniswap-sdk/workflows/CI/badge.svg)](https://github.com/Uniswap/uniswap-sdk)
[![npm version](https://img.shields.io/npm/v/@mapleswap/sdk/latest.svg)](https://www.npmjs.com/package/@mapleswap/sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@mapleswap/sdk/latest.svg)](https://bundlephobia.com/result?p=@mapleswap/sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/Uniswap/uniswap-sdk.git
```

Move into the uniswap-sdk working directory

```sh
cd uniswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```
npm package: @maplex-studio/madatabase
Description: A database management library using Sequelize.
Author: Maplex Studio
Latest version: 2.0.3

# README.md

# MaDatabase

MaDatabase is a TypeScript library that provides a simple and efficient way to manage database connections and operations using Sequelize. It includes methods for connecting to the database, creating tables, inserting data, querying records, and managing the database lifecycle.

## Features

- Connect to various databases using Sequelize.
- Create and manage tables with customizable schemas.
- Perform CRUD operations (Create, Read, Update, Delete) on database records.
- Execute raw SQL queries.
- Sync database tables with the defined models.

## Installation

To install MaDatabase, you can use npm:

```bash
npm install @maplex-studio/madatabase
```

## Usage

Here is a basic example of how to use MaDatabase:

```typescript
import { Database } from '@maplex-studio/madatabase';

const db = new Database({
  dialect: 'sqlite',
  storage: 'path/to/database.sqlite',
});

async function main() {
  await db.connect();

  // Create a new table
  db.createTable('users', {
    name: {
      type: DataTypes.STRING,
      allowNull: false,
    },
    email: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
    },
  });

  // Insert a new user
  await db.insert('users', { name: 'John Doe', email: 'john@example.com' });

  // Find all users
  const users = await db.find('users');
  console.log(users);

  // Close the database connection
  await db.close();
}

main().catch(console.error);
```

## TypeScript Support

MaDatabase is written in TypeScript and provides type definitions for all its methods. You can import the types from the `types` directory to enhance your development experience.

## Contributing

Contributions are welcome! Please feel free to submit a pull request or open an issue for any suggestions or improvements.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
npm package: @maplibre/ngx-maplibre-gl
Description: An Angular binding for maplibre-gl
Latest version: 21.0.2


<div align="center">
  <img src="https://raw.githubusercontent.com/maplibre/ngx-maplibre-gl/main/projects/showcase/src/assets/ngx-maplibre-gl-red.svg" height="128">
</div>
<div align="center">
  <h1>ngx-maplibre-gl</h1>
</div>

Angular wrapper for [maplibre-gl](https://www.maplibre.org/). It exposes a bunch of components meant to be simple to use with Angular.

[![npm version](https://img.shields.io/npm/v/@maplibre/ngx-maplibre-gl.svg?style=flat)](https://www.npmjs.com/package/@maplibre/ngx-maplibre-gl)

### Demo site

Can be found here (based on the generated gh-pages in this repo):
https://maplibre.org/ngx-maplibre-gl/

### Attribution

This is a fork of [ngx-mapbox-gl](https://github.com/Wykks/ngx-mapbox-gl) and I would like to thank the maintainers there for their amazing work to build this up. It's truly a great piece of software!

### API Documentation

[The API documentation can be found here](https://maplibre.org/ngx-maplibre-gl/API/).

## How to start

```
npm install @maplibre/ngx-maplibre-gl maplibre-gl
yarn add @maplibre/ngx-maplibre-gl maplibre-gl
```

There might be a need to add the following configuration to `tsconfig.json` file

```
"compilerOptions": {
    ...
    "strictNullChecks": false,
    "skipLibCheck": true,
}
```

Load the CSS of `maplibre-gl`

For example, with _angular-cli_ add this in `angular.json`:

```json
"styles": [
  ...,
  "./node_modules/maplibre-gl/dist/maplibre-gl.css"
],
```

Or in the global CSS file (called `styles.css` for example in _angular-cli_):

```css
@import '~maplibre-gl/dist/maplibre-gl.css';
```

Then, in your app's main module (or in any other module), import the `MapComponent`:

```ts
import { Component } from '@angular/core';
import { MapComponent } from '@maplibre/ngx-maplibre-gl';

@Component({
  template: `
    <mgl-map
      [mapStyle]="'https://demotiles.maplibre.org/style.json'"
      [zoom]="[9]"
      [center]="[-74.5, 40]"
    >
    </mgl-map>
  `,
  styles: [
    `
      mgl-map {
        height: 100%;
        width: 100%;
      }
    `,
  ],
  imports: [MapComponent],
})
export class AppComponent {}
```

If you use several components, it will be convenient to import `NgxMapLibreGLModule` instead:

```ts
import { Component } from '@angular/core';
import { NgxMapLibreGLModule } from '@maplibre/ngx-maplibre-gl';

@Component({
  template: `
    <mgl-map
      [mapStyle]="'https://demotiles.maplibre.org/style.json'"
      [zoom]="[9]"
      [center]="[-74.5, 40]"
    >
      <mgl-control
        mglNavigation
        [visualizePitch]="true"
    />
    </mgl-map>
  `,
  styles: [
    `
      mgl-map {
        height: 100%;
        width: 100%;
      }
    `,
  ],
  imports: [NgxMapLibreGLModule]
})
export class AppComponent {}
```
npm package: @maplibre/vt-pbf
Description: Serialize mapbox vector tiles to binary protobufs in javascript.
Author: Anand Thakker
Latest version: 4.3.0

[![MapLibre Logo](https://maplibre.org/img/maplibre-logo-big.svg)](https://maplibre.org/)

# vt-pbf 
[![NPM Version](https://img.shields.io/npm/v/@maplibre/vt-pbf.svg)](https://www.npmjs.com/package/@maplibre/vt-pbf)

Serialize [Mapbox vector tiles](https://github.com/mapbox/vector-tile-spec) to binary protobufs in javascript.

## Installation
Using NPM: `npm install @maplibre/vt-pbf`

Or `npm run build` and find build artifacts in `dist/`

## Usage

As far as I know, the two places you might get a JS representation of a vector
tile are [geojson-vt](https://github.com/mapbox/geojson-vt) and
[vector-tile-js](https://github.com/mapbox/vector-tile-js).  These both use
slightly different internal representations, so serializing each looks slightly
different:

## From vector-tile-js

```javascript
import {fromVectorTileJs} from 'vt-pbf'
import {VectorTile} = from '@mapbox/vector-tile'
import Protobuf from 'pbf'

var data = fs.readFileSync(__dirname + '/fixtures/rectangle-1.0.0.pbf')
var tile = new VectorTile(new Protobuf(data))
var orig = tile.layers['geojsonLayer'].feature(0).toGeoJSON(0, 0, 1)

var buff = fromVectorTileJs(tile)
fs.writeFileSync('my-tile.pbf', buff)
```

## From geojson-vt

```javascript
import {fromGeojsonVt} from 'vt-pbf'
import geojsonVt from '@maplibre/geojson-vt'

var orig = JSON.parse(fs.readFileSync(__dirname + '/fixtures/rectangle.geojson'))
var tileindex = geojsonVt(orig)
var tile = tileindex.getTile(1, 0, 0)

// pass in an object mapping layername -> tile object
var buff = fromGeojsonVt({ 'geojsonLayer': tile })
fs.writeFileSync('my-tile.pbf', buff)
```

`fromGeojsonVt` takes two arguments:
- `layerMap` is an object where keys are layer names and values are a geojson-vt tile,
- `options` is an object (optional argument). There are 2 supported keys: `version` to define the version of the mvt spec used and `extent` to define the extent of the tile. `version` defaults to 1 and `extent` to 4096.