open-index/open-npm huggingface dataset:
npm package: @ninjanyungseb/ninjalodash
Description: [Site](https://lodash.com/) | [Docs](https://lodash.com/docs) | [Contributing](https://github.com/ninjanyungseb/ninjalodash/blob/master/.github/CONTRIBUTING.md) | [Wiki](https://github.com/ninjanyungseb/ninjalodash/wiki "Changelog, Roadmap, etc.") | [Code
Latest version: 5.2.3

# lodash

[Site](https://lodash.com/) |
[Docs](https://lodash.com/docs) |
[Contributing](https://github.com/ninjanyungseb/ninjalodash/blob/master/.github/CONTRIBUTING.md) |
[Wiki](https://github.com/ninjanyungseb/ninjalodash/wiki "Changelog, Roadmap, etc.") |
[Code of Conduct](https://code-of-conduct.openjsf.org)

The [Lodash](https://lodash.com/) library exported as a [UMD](https://github.com/umdjs/umd) module.

```shell
$ bun run build
$ lodash -o ./dist/lodash.js
$ lodash core -o ./dist/lodash.core.js
```

## Download

 * [Core build](https://raw.githubusercontent.com/lodash/lodash/4.17.10-npm/core.js) ([~4 kB gzipped](https://raw.githubusercontent.com/lodash/lodash/4.17.10-npm/core.min.js))
 * [Full build](https://raw.githubusercontent.com/lodash/lodash/4.17.10-npm/lodash.js) ([~24 kB gzipped](https://raw.githubusercontent.com/lodash/lodash/4.17.10-npm/lodash.min.js))
 * [CDN copies](https://www.jsdelivr.com/projects/lodash) [![jsDelivr Hits](https://data.jsdelivr.com/v1/package/npm/lodash/badge)](https://www.jsdelivr.com/package/npm/lodash)

Lodash is released under the [MIT license](https://raw.githubusercontent.com/lodash/lodash/4.17.10-npm/LICENSE) & supports modern environments.<br>
Review the [build differences](https://github.com/ninjanyungseb/ninjalodash/wiki/build-differences) & pick one that’s right for you.

## Installation

In a browser:
```html
<script src="lodash.js"></script>
```

Using bun:
```shell
$ bun i lodash
```

In [Bun](https://bun.sh):
```js
// Load the full build.
var _ = require('lodash');
// Load the core build.
var _ = require('lodash/core');
// Load the FP build for immutable auto-curried iteratee-first data-last methods.
var fp = require('lodash/fp');

// Load method categories.
var array = require('lodash/array');
var object = require('lodash/fp/object');

// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
var at = require('lodash/at');
var curryN = require('lodash/fp/curryN');
```

Looking for Lodash modules written in ES6 or smaller bundle sizes? Check out [lodash-es](https://www.npmjs.com/package/lodash-es).

## Why Lodash?

Lodash makes JavaScript easier by taking the hassle out of working with arrays,<br>
numbers, objects, strings, etc. Lodash’s modular methods are great for:

 * Iterating arrays, objects, & strings
 * Manipulating & testing values
 * Creating composite functions

## Module Formats

Lodash is available in a [variety of builds](https://lodash.com/custom-builds) & module formats.

 * [lodash](https://www.npmjs.com/package/lodash) & [per method packages](https://www.npmjs.com/search?q=keywords:lodash-modularized)
 * [lodash-es](https://www.npmjs.com/package/lodash-es), [babel-plugin-lodash](https://www.npmjs.com/package/babel-plugin-lodash), & [lodash-webpack-plugin](https://www.npmjs.com/package/lodash-webpack-plugin)
npm package: @ninjas4744/lib
Description: A package of components and utilities used in apps written by FRC team Ninjas #4744
Author: Kfiros
Latest version: 0.1.3

# @ninjas4744/lib
[![FRC - Ninjas #4744](https://img.shields.io/badge/FRC-Ninjas_%234744-blue?logo=First)](https://ninjas4744-website.vercel.app/)
![NPM Version](https://img.shields.io/npm/v/%40ninjas4744%2Flib)

A package of components and utilities used in apps written by FRC team Ninjas #4744

# Usage of components

## Form fields

![](./assets/form_fields.gif)

### TextField
Basic text form field

```tsx
<TextField label="Your Name" value={name} onChangeText={setName} />
```

### Autocomplete
```tsx
const goats = [
  "Joel Matip",
  "Divock Origi",
  "Dominik Szoboszlai"
];
<Autocomplete label="Who is the best player ever?" value={goat} onChangeText={setGoat} suggestions={goats} />
```

### Dropdown
```tsx
<Dropdown label="What is your favorite color?" value={color} onValueChange={setColor} options={["Red", "Green", "Blue"]} />
```

### Checkbox
```tsx
<Checkbox label="I agree to the terms and conditions" cheked={agree} onValueChange={setAgree} />
```

### Radio
```tsx
<Radio label="Blue" selected={alliance === 'blue'} onValueChange={() => setAlliance('blue')} />
<Radio label="Red" selected={alliance === 'red'} onValueChange={() => setAlliance('red')} />
```

## Layout

### Stack
```tsx
<Stack direction="column" style={{ padding: 30 }}>
  <TextField label="First Name" value={firstName} onChangeText={setFirstName} />
  <TextField label="Last Name" value={lastName} onChangeText={setLastName} />
</Stack>
```

### Container
```tsx
<Container style={{ padding: 30 }} centered>
  <Text>Some content</Text>
</Container>
```

### Add the package to your npm dependencies

```
npm install @ninjas4744/lib
```

# Contributing

Contributions are very welcome! Please refer to guidelines described in the [contributing guide]( https://github.com/expo/expo#contributing).
npm package: @ninjutsu-build/biome
Description: A biome plugin for ninjutsu-build
Author: Elliot Goodrich
Latest version: 0.10.0

# biome - Ninjutsu Build

A package to create a `ninjutsu-build` rule for linting and formatting files With
[Biome](https://biomejs.dev/).

## Installation

Most likely you require both `@ninjutsu-build/biome` and `@ninjutsu-build/code` as a
`devDependency`, which can be achieved by running the following `npm` command:

```bash
$ npm install @ninjutsu-build/core @ninjutsu-build/biome --save-dev
```

## Basic Example

The following formats all `*.test.js` files in the `tests` directory, and then
runs those tests with node's test runner, while linting those JavaScript files
in parallel.

```ts
import { NinjaBuilder } from "@ninjutsu-build/core";
import { makeFormatRule, makeLintRule } from "@ninjutsu-build/biome";
import { makeNodeTestRule } from "@ninjutsu-build/node";
import { writeFileSync } from "fs";

// Create a `NinjaBuilder` requiring 1.11 (for validations)
const ninja = new NinjaBuilder({
  ninja_required_version: "1.11",
  builddir: ".mybuilddir",
});

// Create our rules
const format = makeFormatRule(ninja);
const lint = makeLintRule(ninja);
const test = makeNodeTestRule(ninja);

const biomeConfig = "biome.json",

// For each test file, format, lint, and run it in node
for (const js of globSync("tests/*.test.js", { posix: true })) {
  const formatted = format({ in: js, configPath: biomeConfig });
  const linted = lint({ in: formatted, configPath: biomeConfig });
  test({
    in: linted,
    out: `$builddir/results/${js}.txt`,
  });
};

// Write the ninja file to disk
writeFileSync("build.ninja", ninja.output);
```
npm package: @ninjutsu-build/bun
Description: A bun plugin for ninjutsu-build
Author: Elliot Goodrich
Latest version: 0.3.0

# bun - Ninjutsu Build

A package to create a `ninjutsu-build` rule for transpiling TypeScript to JavaScript
using [bun](https://bun.sh).

There are no rules in `@ninjutsu-build/bun` for bundling as this would require `bun`
to output all of the files that have been bundled while processing a particular entry
point.  This would allow us to save this to an appropriate `dyndep` file and use this
in the rule.

There are no rules in `@ninjutsu-build/bun` to execute JavaScript as this would
require `bun` to output all the files that have been `import`ed or `require`d (or allow
us to intercept those calls which is done with `@ninjutsu-build/node`) so we can
create a `dyndep` file to capture all of the dependencies.

## Installation

Make sure `bun` is installed by following their
[instructions](https://bun.sh/docs/installation).

Most likely you require both `@ninjutsu-build/bun` and `@ninjutsu-build/code` as a
`devDependency`, which can be achieved by running the following `npm` command:

```bash
$ npm install @ninjutsu-build/core @ninjutsu-build/bun --save-dev
```

## Basic Example

The following transpiles all `*.test.ts` files in the `tests` directory to
JavaScript,

```ts
import { NinjaBuilder } from "@ninjutsu-build/core";
import { makeTranspileRule } from "@ninjutsu-build/bun";
import { globSync } from "glob";

const ninja = new NinjaBuilder();
const transpile = makeTranspileRule(ninja);

globSync("src/*.tests.ts", { posix: true }).map((ts) =>
 transpile({
    in: ts,
    out: join("$builddir", "dist", basename(file, extname(file)) + ".mjs"),
    args: "--target node",
  })
);

writeFileSync("build.ninja", ninja.output);
```
npm package: @ninjutsu-build/core
Description: Easily create ninja build files with this TypeScript library (https://ninja-build.org/)
Author: Elliot Goodrich
Latest version: 0.9.0

# Ninjutsu Build

A TypeScript library for creating ninja files (https://ninja-build.org/).

## Why Ninjutsu Build?

Some of the selling points of `ninjutsu-build` are:

  * TypeScript
  * Type-safe design - easy to create build rules that require certain variables, or
    can have optionally specified variables
  * Simple and quick - all methods calls write directly to a `string` property
  * Ninja rules return the value of the `out` argument, which makes it easier to use
    linting tools to find unused build artifatcts
  * Zero dependencies

## Prerequisites

This project requires NodeJS (version 18 or later) and npm.

## Installation

Most likely you require `@ninjutsu-build/core` as a `devDependency`, which can be
achieved by running the following `npm` command:

```bash
$ npm install @ninjutsu-build/core --save-dev
```

## Basic Example

```ts
import { NinjaBuilder, needs } from "@ninjutsu-build/core";
import { writeFileSync } from "fs";

// Create a `NinjaBuilder`
const ninja = new NinjaBuilder({
  ninja_required_version: "1.1",
  builddir: ".mybuilddir",
});

// Create the `touch` rule
const touch = ninja.rule("touch", {
  command: "touch $out",
  description: "Creating $out",
  out: needs<string>(),
});

// Create a build edge using `touch` and store the value
// of the `out` property
const example = touch({
  out: "$builddir/example.stamp",
});

// Create the `copy` rule
const copy = ninja.rule("cp", {
  command: "cp $in $out",
  description: "Copying $in to $out",
  out: needs<string>(),
  in: needs<string>(),
});

// Copy the file created previously
copy({
    in: example,
    out: "$builddir/example.copy.stamp",
});

// Write the ninja file to disk
writeFileSync("build.ninja", ninja.output);
```
npm package: @ninjutsu-build/esbuild
Description: An esbuild plugin for ninjutsu-build
Author: Elliot Goodrich
Latest version: 0.3.1

# esbuild - Ninjutsu Build

A package to create a `ninjutsu-build` rule for running
[esbuild](https://esbuild.github.io/).

## Installation

Most likely you require both `@ninjutsu-build/esbuild` and `@ninjutsu-build/code` as a
`devDependency`, which can be achieved by running the following `npm` command:

```bash
$ npm install @ninjutsu-build/core @ninjutsu-build/esbuild --save-dev
```

## Basic Example

The following transpiles all `*.test.ts` files in the `tests` directory to
JavaScript,

```ts
import { NinjaBuilder } from "@ninjutsu-build/core";
import { makeESBuildRule } from "@ninjutsu-build/esbuild";
import { globSync } from "glob";

const ninja = new NinjaBuilder();
const esbuild = makeESBuildRule(ninja);

globSync("src/*.tests.ts", { posix: true }).map((ts) =>
 esbuild({
    in: ts,
    out: join("$builddir", "dist", basename(file, extname(file)) + ".mjs"),
    buildOptions: { bundle: true, format: "esm" },
  })
);

writeFileSync("build.ninja", ninja.output);
```
npm package: @ninjutsu-build/node
Description: A ninjutsu-build plugin to generate ninja rules to execute JavaScript with node
Author: Elliot Goodrich
Latest version: 0.13.0

# Node - Ninjutsu Build

A package to create a `ninjutsu-build` rule for running JavaScript files within node.

## Prerequisites

This project requires NodeJS (version 18.18.0 or later for
[`--import` support](https://nodejs.org/api/cli.html#--importmodule)) and npm.

## Installation

Most likely you require both `@ninjutsu-build/node` and `@ninjutsu-build/code` as a
`devDependency`, which can be achieved by running the following `npm` command:

```bash
$ npm install @ninjutsu-build/core @ninjutsu-build/node --save-dev
```

## Basic Example

Given the following simple JavaScript file that prints out numbers 
1 to N,

```js
// count.js
const process = require('node:process');

const limit = parseInt(process.argv[2]);
for (let i = 1; i < limit; ++i) {
  console.log(i);
}
```

We can build a `build.ninja` file that will invoke `count.js` and
save the output,

```ts
import { NinjaBuilder, [implicitDeps] } from "@ninjutsu-build/core";
import { makeNodeRule } from "@ninjutsu-build/node";
import { writeFileSync } from "fs";

// Create a `NinjaBuilder`
const ninja = new NinjaBuilder({
  ninja_required_version: "1.1",
  builddir: ".mybuilddir",
});

// Create a `runJS` ninja rule
const node = makeNodeRule(ninja, "runJS");

// Run `src/count.js` and save to `$builddir/output.txt`.
// Pass the `.package-lock.json` file as an implicit dependency
// so that installing or changing dependencies will cause ninja
// to regenerate `output.txt`.
const output = node({
  in: "src/count.js",
  out: "$builddir/output.txt",
  args: 10, // pass `10` to `count.js`
  [implicitDeps]: ["src/node_modules/.package-lock.json"],
});

// Write the ninja file to disk
writeFileSync("build.ninja", ninja.output);
```
npm package: @ninjutsu-build/tsc
Description: Create a ninjutsu-build rule for running the TypeScript compiler (tsc)
Author: Elliot Goodrich
Latest version: 0.14.0

# TSC - Ninjutsu Build

A package to create a `ninjutsu-build` rule for running TSC.

## Installation

Most likely you require both `@ninjutsu-build/tsc` and `@ninjutsu-build/core` as a
`devDependency`, which can be achieved by running the following `npm` command:

```bash
$ npm install @ninjutsu-build/core @ninjutsu-build/tsc --save-dev
```

## Basic Example

Given the following simple JavaScript file that prints out numbers 
1 to N,

```ts
// index.ts
console.log("Hello World!");
```

We can build a `build.ninja` file that will compile `index.ts` and
use `@ninjutsu-build/node` to run the resulting JavaScript,

```ts
import { NinjaBuilder } from "@ninjutsu-build/core";
import { makeTSCRule } from "@ninjutsu-build/tsc";
import { makeNodeRule } from "@ninjutsu-build/node";
import { writeFileSync } from "fs";

// Create a `NinjaBuilder`
const ninja = new NinjaBuilder({
  ninja_required_version: "1.1",
  builddir: ".mybuilddir",
});

// Create the `tsc` rule and compile `index.ts` to `dist`
const tsc = makeTSCRule(ninja);
const js = tsc({
  in: ["index.ts"],
  compilerOptions: {
    outDir: "dist",
  }
});

// Create the `node` rule and invoke the generated JavaScript file,
// saving the output to `$builddir/output.txt`.
const node = makeNodeRule(ninja);
node({
  in: js,
  out: "$builddir/output.txt",
});

// Write the ninja file to disk
writeFileSync("build.ninja", ninja.output);
```
npm package: @ninna-ui/react-internal
Description: Radix UI engine adapters for Ninna UI - isolates Radix dependencies behind clean TypeScript interfaces, prevents type leakage.
Author: Ninna-UI Team
Latest version: 0.5.0

# @ninna-ui/react-internal

> **Radix UI isolation layer for Ninna UI** - wraps 11 Radix primitives behind clean TypeScript interfaces so **no Radix types, imports, or dependencies ever leak into your code**. The architecture that makes Ninna UI's API clean while keeping Radix's accessibility bulletproof.

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](../../LICENSE)

This package is **auto-installed** as a dependency of `@ninna-ui/forms`, `@ninna-ui/overlays`, and `@ninna-ui/navigation`. You do **not** need to install it directly - it's an internal implementation detail.

## Why This Exists

Ninna UI uses [Radix UI](https://www.radix-ui.com/) for complex accessible components (Select, Modal, Tabs, Accordion, etc.) but wraps every Radix primitive behind an "engine" abstraction. This architectural decision gives you:

- **Zero Radix in your imports** - consumers never see or type against Radix. Your code stays clean
- **Upgrade-safe API** - Radix can be upgraded or even swapped to a different engine without breaking your app
- **Minimal bundle impact** - only the engines your imported components use are included. Tree-shaking works perfectly

## Used By

| Package | Engines Used |
|---------|-------------|
| `@ninna-ui/forms` | CheckboxEngine, SwitchEngine, RadioEngine, SelectEngine, SliderEngine |
| `@ninna-ui/overlays` | DialogEngine, PopoverEngine, TooltipEngine, DropdownEngine |
| `@ninna-ui/navigation` | TabsEngine, AccordionEngine |

## Engines

Radix component wrappers with Ninna UI's own type interfaces:

| Engine | Radix Package | Used For |
|--------|--------------|----------|
| `checkbox-engine` | `@radix-ui/react-checkbox` | Checkbox, CheckboxGroup |
| `switch-engine` | `@radix-ui/react-switch` | Switch |
| `radio-engine` | `@radix-ui/react-radio-group` | RadioGroup, RadioCard |
| `select-engine` | `@radix-ui/react-select` | Select |
| `slider-engine` | `@radix-ui/react-slider` | Slider |
| `dialog-engine` | `@radix-ui/react-dialog` | Modal, Drawer |
| `popover-engine` | `@radix-ui/react-popover` | Popover |
| `tooltip-engine` | `@radix-ui/react-tooltip` | Tooltip |
| `dropdown-engine` | `@radix-ui/react-dropdown-menu` | DropdownMenu |
| `tabs-engine` | `@radix-ui/react-tabs` | Tabs |
| `accordion-engine` | `@radix-ui/react-accordion` | Accordion |

## Primitives

- **`Slot`** - Polymorphic component slot for the `asChild` pattern

## Architecture Rules

- **NO Radix types** in exported interfaces - wrap everything
- **NO direct imports** from apps - only `@ninna-ui/*` packages may import this
- **NO `@radix-ui/*` imports** anywhere else in the monorepo

## Related Packages

- [`@ninna-ui/utils`](../utils/README.md) - Shared utility functions
- [`@ninna-ui/core`](../core/README.md) - Design tokens and theme presets
- [All packages](../../README.md#packages) - Complete package list

## License

[MIT](../../LICENSE)
npm package: @ninnana/koishi-plugin-24point
Description: 一个24点小游戏，功能不再变更，失效前不再更新。
Latest version: 0.0.11

# koishi-plugin-24point

[![npm](https://img.shields.io/npm/v/koishi-plugin-24point?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-24point)

24point game
npm package: @ninoop/tng-design-system
Description: Tng Design System - A React UI component library
Latest version: 0.2.5

# Tng Design System

[![npm version](https://img.shields.io/npm/v/@ninoop/tng-design-system.svg)](https://www.npmjs.com/package/@ninoop/tng-design-system)
[![npm downloads](https://img.shields.io/npm/dm/@ninoop/tng-design-system.svg)](https://www.npmjs.com/package/@ninoop/tng-design-system)

## Install
```bash
npm i @ninoop/tng-design-system
npm package: @ninoseki/eslint-plugin-neverthrow
Description: [eslint-plugin-neverthrow](https://github.com/mdbetancourt/eslint-plugin-neverthrow) but works with ESLint v10.
Author: Manabu Niseki
Latest version: 0.1.1

# @ninoseki/eslint-plugin-neverthrow

[eslint-plugin-neverthrow](https://github.com/mdbetancourt/eslint-plugin-neverthrow) but works with ESLint v10.

## Installation

```bash
npm install --save-dev @ninoseki/eslint-plugin-neverthrow typescript-eslint
```

## Requirements

- ESLint v10+
- `typescript-eslint`

## Usage

```ts
import { defineConfig } from 'eslint/config'
import tseslint from 'typescript-eslint'
import neverthrow from '@ninoseki/eslint-plugin-neverthrow'

export default defineConfig(
  ...tseslint.configs.recommended,
  {
    plugins: { neverthrow },
    rules: {
      'neverthrow/must-use-result': 'error',
    },
    languageOptions: {
      parserOptions: {
        project: './tsconfig.json',
      },
    },
  },
)
```

## Rules

Same as https://github.com/mdbetancourt/eslint-plugin-neverthrow/tree/master?tab=readme-ov-file#rules.
npm package: @ninoslat1/easse
Description: Lightweight SSE adapters for your backend
Author: ninoslat1
Latest version: 0.0.6


# Easse
Lightweight SSE adapter for backend.

## Key Features

* 🌎 Universal Compatibility
* 🔌 Seamless Integration
* ⚡ Lightweight
* ➕ Extensible

Easse is a lightweight, zero-dependency library for managing Server-Sent Events (SSE). It features an universal compatibility with JavaScript Runtimes, easily extend with CORS configuration and data pooling interval, and zero dependency for the lightweight performance.

## Installation

```bash
bun add @ninoslat1/easse
# or
npm install @ninoslat1/easse
# or
pnpm install @ninoslat1/easse
```
    
## Documentation


## License

MIT
npm package: @ninternal/currency-codes
Description: Lookup currency codes based on ISO 4217
Latest version: 2.2.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# currency-codes

A node.js module to list and work on currency codes based on the [ISO 4217](http://en.wikipedia.org/wiki/ISO_4217) standard.

	npm install currency-codes

## code('EUR')

``` js
var cc = require('currency-codes');
console.log(cc.code('EUR'));

/*
{
	code: 'EUR',
	number: 978,
	digits: 2,
	currency: 'Euro',
	countries: [
		'andorra', 'austria', 'belgium', 'cyprus', 'estonia', 'finland',
		'france', 'germany', 'greece', 'ireland', 'italy', 'kosovo',
		'luxembourg', 'malta', 'monaco', 'montenegro', 'netherlands',
		'portugal', 'san marino', 'slovakia', 'slovenia', 'spain',
		'vatican city' ]
}
*/
```

## number(967)

``` js
var cc = require('currency-codes');
console.log(cc.number(967));

/*
{
	code: 'ZMW',
	number: 967,
	digits: 2,
	currency: 'Zambian kwacha',
	countries: [ 'zambia' ] }
*/
```

## country('colombia')

``` js
var cc = require('currency-codes');
console.log(cc.country('colombia'));

/*
[
	{
		code: 'COP',
		number: 170,
		digits: 2,
		currency: 'Colombian peso',
		countries: [ 'colombia' ]
	}, {
		code: 'COU',
		number: 970,
		digits: 2,
		currency: 'Unidad de Valor Real',
		countries: [ 'colombia' ]
	}
]
*/
```

## codes()

``` js
var cc = require('currency-codes');
console.log(cc.codes());

/*
[
	'AED',
	'AFN',
	...
	'ZAR',
	'ZMW'
]
*/
```

## numbers()

``` js
var cc = require('currency-codes');
console.log(cc.numbers());

/*
[
	'784',
	'971',
	...
	'710',
	'967'
]
*/
```

## countries()

``` js
var cc = require('currency-codes');
console.log(cc.countries());

/*
[ 
	'united arab emirates',
	'afghanistan',
	...
]
*/
```

## data

``` js
var data = require('currency-codes/data');
console.log(data);

/*
[{
	code: 'AED',
	number: '784',
	digits: 2,
	currency: 'United Arab Emirates dirham',
	countries: ['united arab emirates']
}, {
	code: 'AFN',
	number: '971',
	digits: 2,
	currency: 'Afghan afghani',
	countries: ['afghanistan']
}, {
	...
*/
```

## publishDate

```js
var cc = require('currency-codes');

console.log(cc.publishDate);

/*
2018-08-29
*/
```

## ISO-4217

Fetch the latest copy of ISO-4217 from the [maintainer](https://www.currency-iso.org/) and update this library's currency data file.

```bash
$ npm run iso

> currency-codes@1.5.1 iso currency-codes
> npm run iso:fetch-xml && npm run iso:ingest-xml


> currency-codes@1.5.1 iso:fetch-xml currency-codes
> node scripts/fetch-iso-4217-xml.js

Downloaded https://www.currency-iso.org/dam/downloads/lists/list_one.xml to iso-4217-list-one.xml

> currency-codes@1.5.1 iso:ingest-xml currency-codes
> node scripts/ingest-iso-4217-xml.js

Ingested iso-4217-list-one.xml into data.js
Wrote publish date to iso-4217-publish-date.js
```

Note: You may have to manually tweak the capitalization of some country's names.

# License

MIT