open-index/open-npm huggingface dataset:
npm package: @ramitos/load-script
Description: Dynamic script loading for browser
Latest version: 1.0.2

# load-script

Dynamic script loading.

## Installation

via component

```
$ component install eldargab/load-script
```

via npm

```
$ npm install load-script
```

## API
`load-script` appends a `script` node to the `<head>` element in the dom.

`require('load-script')` returns a function of the following interface:  `function(url[, opts][, cb]) {}`

### url
Any url that you would like to load.  May be absolute or relative.

### [, opts]
A map of options.  Here are the currently supported options:

* `async` - A boolean value used for `script.async`.  By default this is `true`.
* `attrs` - A map of attributes to set on the `script` node before appending it to the DOM.  By default this is empty.
* `charset` - A string value used for `script.charset`.  By default this is `utf8`.
* `text` - A string of text to append to the `script` node before it is appended to the DOM.  By default this is empty.
* `type` - A string used for `script.type`.  By default this is `text/javascript`.

### [, cb]
A callback function of the following interface: `function(err, script) {}` where `err` is an error if any occurred and `script` is the `script` node that was appended to the DOM.

## Example Usage

```javascript
var load = require('load-script')

load('foo.js', function (err, script) {
  if (err) {
    // print useful message
  }
  else {
    console.log(script.src);// Prints 'foo'.js'
    // use script
    // note that in IE8 and below loading error wouldn't be reported
  }
})
```

## License

MIT
npm package: @ramitos/styled-flex-component
Description: Flex Element for not writing any more custom flex styles because fuck that
Latest version: 2.0.2

# Styled Flex Component

[![Codecov](https://codecov.io/gh/SaraVieira/styled-flex-component/branch/master/graph/badge.svg)](https://codecov.io/gh/SaraVieira/styled-flex-component) [![Build Status](https://travis-ci.org/SaraVieira/styled-flex-component.svg)](https://travis-ci.org/SaraVieira/styled-flex-component)

Flex Element for not writing any more custom flex styles because fuck that

## Install

```
yarn add styled-flex-component
or
npm i styled-flex-component
```

## Usage

```jsx
import React from 'react';
import Flex, { FlexItem } from 'styled-flex-component';

export default () => (
  <Flex center full>
    <FlexItem order="2">World</FlexItem>
    <FlexItem order="1">Hello</FlexItem>
  </Flex>
);
```

## Props

All props without description are just true or false values and take no arguments

### Flex Container

#### General

* full -> Sets width, height and flex basis to 100%
* inline -> Sets the item to inline-flex
* center -> Sets justify-content and align-items to center

#### Direction

* rowReverse
* column
* columnReverse

#### Wrap

* wrap
* wrapReverse

#### Align Items

* alignCenter
* alignStart
* alignEnd
* alignBaseline
* alignStretch
* alignCenter

#### Align Content

* contentCenter
* contentStart
* contentEnd
* contentBaseline
* contentStretch
* contentAround
* contentStretch

#### Justify Content

* justifyCenter
* justifyStart
* justifyEnd
* justifyBetween
* justifyAround
* justifyEvenly

### Flex Item

* Order -> Takes a number to se the order of that item
* basis -> Takes a number to se the flex-basis of that item
* grow
* shrink
* noShrink

# License

MIT
npm package: @ramitos/writable
Description: Easily implement a writable stream
Author: Brian M. Carlson
Latest version: 1.0.0

node-writable
=============

More easily construct writable streams.  `writable` is a small shortcut to help construct writable streams,
much the same way that [through2](https://github.com/rvagg/through2) is a shortcut for constructing through streams.

### install

```sh
$ npm i writable
```

### use

Very contrived examples follow:

```js
var writable = require('writable')

//standard
var out = writable(function(chunk, enc, cb) {
  console.log(chunk.toString())
  cb()
})
out.write('hello world') //output => hello world

//implicit callback
var implicit = writable(function(chunk) {
  console.log(chunk)
})
implicit.write('hello world') //output => hello world

//object mode with implicit callback
var objStream = writable({objectMode: true}, function(obj) {
  console.log(obj.name)
})
objStream.write({name: 'Brian'}) //output => Brian
```

### api

`require('writable')` returns a function `makeWritable` that builds a writable stream for you.  This function accepts a callback function 
that takes 1 or more arguments.  Normally you'd accept `item`, `encoding`, and `callback` in this method, just like
the method signature for [Writable._write](http://nodejs.org/api/stream.html#stream_writable_write_chunk_encoding_callback_1).

`makeWritable` will sniff the method arguments on the callback you pass into it.  If it sees only 1 argument, it will
implicitly call the callback for you.  That's a handy little shortcut for the common case of doing something on the writer
that is a sync action.

That's really all there is to it.

### license

The MIT License (MIT)

Copyright (c) 2014 Brian M. Carlson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
npm package: @ramitos/xmldom
Description: A W3C Standard XML DOM(Level2 CORE) implementation and parser(DOMParser/XMLSerializer)
Author: Sérgio Ramos
Latest version: 1.0.0

# xmldom

![](https://img.shields.io/travis/ramitos/xmldom.svg) ![](https://img.shields.io/codeclimate/coverage/github/ramitos/xmldom.svg) ![](https://img.shields.io/npm/v/@ramitos/xmldom.svg) ![](https://img.shields.io/david/ramitos/xmldom.svg) ![](https://img.shields.io/codeclimate/github/ramitos/xmldom.svg) ![](https://img.shields.io/npm/l/xmldom.svg)


taken from [here](http://stackoverflow.com/questions/12980648/map-html-to-json)
npm package: @ramiyohay/schema-faker
Description: Generate fake data from Zod schemas in a deterministic way
Latest version: 0.6.0

# schema-faker

Generate fake data from **Zod schemas** in a deterministic, type-safe, and extensible way.

`schema-faker` creates realistic-looking mock data **directly from your existing schemas**, without writing manual mocks.

---

## Why schema-faker?

Most fake data libraries generate random values field-by-field.  
`schema-faker` works **schema-first**.

### Benefits
- ✅ Uses schemas you already have (Zod)
- ✅ Deterministic output (seed support)
- ✅ Fully type-safe
- ✅ No dependency on Faker
- ✅ Perfect for tests, seeds, and mock APIs

### Type Support
- ✅ string
- ✅ number
- ✅ boolean
- ✅ object
- ✅ array
- ✅ optional
- ✅ enum
- ✅ nullable
- ✅ tuple
- ✅ union
- ✅ literal
- ✅ date
- ✅ record


## Install
npm install schema-faker zod

## Basic Usage
```ts
import { z } from "zod";
import { generate } from "schema-faker";

const User = z.object({
  id: z.string().uuid(),
  email: z.string().email(),
  age: z.number().min(18)
});

const user = generate(User);

// you can also create multi objects

const users = generate(User, {
  count: 5,
  seed: 42,
});
```

# Override Data Usage
```ts
import { z } from "zod";
import { generate } from "schema-faker";

const UserSchema = z.object({
  id: z.string().uuid(),
  email: z.string().email(),
  age: z.number().min(18).max(65),
  isActive: z.boolean(),
});

// email and age will stay the same
const user = generate(UserSchema, {
  overrides: {
    email: "test@example.com",
    age: 30,
  },
});

console.log(user);
```

### Strict mode

By default, unsupported Zod types are ignored.
Enable strict mode to throw an error instead:

```ts
generate(schema, { strict: true });
```