open-index/open-npm huggingface dataset:
npm package: @immutabl3/tween
Description: trimmed down, modern version of sole/tween for tree shaking
Author: Immutable, LLC
Latest version: 1.0.0

# micro-tween

A trimmed down, modern version of [sole's tween.js](https://github.com/tweenjs/tween.js/) for treeshaking

`npm i micro-tween`

### notable changes

Easing functions are located in `micro-tween/ease` to be imported to save on file size. Polyfills for `window.performance.now` have been removed in favor of `Date.now` (keeping node support via process.hrtime).

Additional removals:
* no interpolation
* no string relative values
* no safety checks
* no `this` context in functions, use passed object
* no constructor function/generated code
* no `getAll`/`removeAll` tweens

Everything else should work!

### Example

```js
import tween, {
  update,
  elasticInOut
} from 'micro-tween';

tween({ x: 0 })
  .to({ x: 100 })
  .yoyo()
  .repeat(2)
  .ease(elasticInOut)
  .onStart(function() {
    console.log('start');
  })
  .onUpdate(function(value) {
    console.log('value: ', value.x);
  })
  .onComplete(function() {
    console.log('complete');
  })
  .start();

const tick = function() {
  update();
  requestAnimationFrame(tick);
};
tick();
```
npm package: @immutabl3/utils
Description: a modern javascript utility function library based on [You Don't Need](https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore) and [You Might Not Need](https://youmightnotneed.com/lodash/)
Author: Immutable, LLC
Latest version: 2.0.2

# utils

a modern javascript utility function library based on [You Don't Need](https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore)
and [You Might Not Need](https://youmightnotneed.com/lodash/)

Written with modern javascript and built to be tree shaken

Zero `0` dependencies

## Functions

WIP
npm package: @immutable-array/copy-within
Description: Immutable Array.prototype.copyWithin().
Author: azu
Latest version: 1.0.6

# @immutable-array/copy-within

Immutable [`Array.prototype.copyWithin()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin).

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/copy-within

## Usage

Same API with [`Array.prototype.copyWithin()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin)

```ts
/**
 * Returns the this object after copying a section of the array identified by start and end
 * to the same array starting at position target
 * @param array Base array
 * @param target If target is negative, it is treated as length+target where length is the
 * length of the array.
 * @param start If start is negative, it is treated as length+start. If end is negative, it
 * is treated as length+end.
 * @param end If not specified, length of the this object is used as its default value.
 */
export declare function copyWithin<T>(array: Array<T>, target: number, start: number, end?: number): Array<T>;
```

## Example

```js
import { copyWithin } from "@immutable-array/copyWithin";
const originalArray = [1, 2, 3, 4, 5];
assert.deepStrictEqual(copyWithin(originalArray, -2), [1, 2, 3, 1, 2]);
assert.deepStrictEqual(copyWithin(originalArray, 0, 3), [4, 5, 3, 4, 5]);
assert.deepStrictEqual(copyWithin(originalArray, 0, 3, 4), [4, 2, 3, 4, 5]);
assert.deepStrictEqual(copyWithin(originalArray, 0, -2, -1), [4, 2, 3, 4, 5]);
```

TODO: Array-like.

This is not specified behavior.

If you interesting in this, Please comment to [copyWithIn() with Array-like · Issue #20 · azu/immutable-array-prototype](https://github.com/azu/immutable-array-prototype/issues/20 "copyWithIn() with Array-like · Issue #20 · azu/immutable-array-prototype").

```js
import { copyWithin } from "@immutable-array/copyWithin";
const arrayLike = { length: 5, 3: 1 };
let actual = copyWithin(arrayLike, 0, 3);
assert.deepStrictEqual(actual, [1, , , 1,]);
```

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/fill
Description: Immutable Array.prototype.fill.
Author: azu
Latest version: 1.0.6

# @immutable-array/fill

Immutable [`Array.prototype.fill()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/fill).

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/fill

## Usage

Same API with [`Array.prototype.fill()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/fill).

```ts
/**
 * Returns the this object after filling the section identified by start and end with value
 * @param array base array
 * @param value value to fill array section with
 * @param start index to start filling the array at. If start is negative, it is treated as
 * length+start where length is the length of the array.
 * @param end index to stop filling the array at. If end is negative, it is treated as
 * length+end.
 */
export declare function fill<T>(array: Array<T>, value: T, start?: number, end?: number): Array<T>;
```

## Example

```js
import { fill } from "@immutable-array/fill" 
const originalArray = [1, 2, 3];
assert.deepStrictEqual(fill(originalArray, "x"), ["x", "x", "x"]);
assert.deepStrictEqual(fill(originalArray, "x", 1, 2), [1, "x", 3]);
```

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/pop
Description: Immutable Array.prototype.pop.
Author: azu
Latest version: 1.0.6

# @immutable-array/pop

Immutable [`Array.prototype.pop()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/pop

## Usage

Same API with [`Array.prototype.pop()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)

```ts
/**
 * Removes the last element from an array and returns it.
 */
export declare function pop<T>(array: Array<T>): T[];
```

## Example

```js
import { pop } from "@immutable-array/pop";
const originalArray = ["a", "b", "c", "d", "e"];
const resultArray = pop(originalArray);
assert.deepStrictEqual(resultArray, ["a", "b", "c", "d"]);
```

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/prototype
Description: Collection of immutable Array.prototype methods.
Author: azu
Latest version: 1.0.6

# @immutable-array/prototype

Collection of immutable `Array.prototype` methods.

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/prototype

## Usage

Please see [README.md on the root](../../README.md).

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/push
Description: Immutable Array.prototype.push
Author: azu
Latest version: 1.0.6

# @immutable-array/push

Immutable [`Array.prototype.push()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/push)

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/push

## Usage

Same API with [`Array.prototype.push()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/push).

```ts
/**
 * Appends new elements to an array, and returns the new length of the array.
 * @param array base Array
 * @param items New elements of the Array.
 */
export declare function push<T>(array: Array<T>, ...items: T[]): Array<T>;
```

## Example

```js
import { push } from "@immutable-array/push";
const originalArray = ["a", "b", "c", "d", "e"];
const resultArray = push(originalArray, "f", "g");
assert.ok(originalArray !== resultArray);        
```

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/reverse
Description: Immutable Array.prototype.reverse
Author: azu
Latest version: 1.0.6

# @immutable-array/reverse

Immutable [`Array.prototype.reverse()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse).

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/reverse

## Usage

Same API with [`Array.prototype.reverse()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse).

```ts
/**
 * Reverses the elements in an Array.
 * @param array base array
 */
export declare function reverse<T>(array: Array<T>): Array<T>;
```

## Example

```js
import { reverse } from "@immutable-array/reverse"
assert.deepStrictEqual(reverse(["a", "b", "c", "d", "e"]), ["e", "d", "c", "b", "a"]);
assert.deepStrictEqual(reverse([1, 2, 3, 4, 5]), [5, 4, 3, 2, 1]);
assert.deepStrictEqual(reverse([true, Infinity, undefined, undefined, "NaN", "-1"]), [
    "-1",
    "NaN",
    undefined,
    undefined,
    Infinity,
    true
]);
```

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/shift
Description: Immutable Array.prototype.shift.
Author: azu
Latest version: 1.0.6

# @immutable-array/shift

Immutable [`Array.prototype.shift()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/shift).

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/shift

## Usage

Same API with [`Array.prototype.shift()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/shift).

```ts
/**
 * Removes the first element from an array and returns it.
 */
export declare function shift<T>(array: Array<T>): Array<T>;
```

## Example

```js
import { shift } from "@immutable-array/shift"
const originalArray = ["a", "b", "c", "d", "e"];
const resultArray = shift(originalArray);
assert.deepStrictEqual(resultArray, ["b", "c", "d", "e"]);
```

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/sort
Description: Immutable Array.prototype.sort.
Author: azu
Latest version: 1.0.6

# @immutable-array/sort

Immutable [`Array.prototype.sort()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/sort).

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/sort

## Usage

Same API with [`Array.prototype.sort()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/sort).

```ts
/**
 * Sorts an array.
 * @param array Base array
 * @param compareFn The name of the function used to determine the order of the elements. If omitted, the elements are sorted in ascending, ASCII character order.
 */
export declare function sort<T>(array: Array<T>, compareFn?: (a: T, b: T) => number): Array<T>;
```

## Example

Default sort:

```js
import { sort } from "@immutable-array/sort"
assert.deepStrictEqual(sort(["a", "b", "c", "d", "e"]), ["a", "b", "c", "d", "e"]);
assert.deepStrictEqual(sort(["e", "a", "c", "b", "d"]), ["a", "b", "c", "d", "e"]);
assert.deepStrictEqual(sort([1, 5, 2, 4, 3]), [1, 2, 3, 4, 5]);
assert.deepStrictEqual(sort([5, 2, 4, 3, 1]), [1, 2, 3, 4, 5]);
assert.deepStrictEqual(sort(["1", "10", "2"]), ["1", "10", "2"]);
assert.deepStrictEqual(sort(["10", "2", "1"]), ["1", "10", "2"]);
```

Custom sort:

```js
import { sort } from "@immutable-array/sort"
const numberArray = [20, 3, 4, 10, -3, 1, 0, 5];
const resultArray = sort(numberArray, (a, b) => b - a);
assert.deepStrictEqual(resultArray, [20, 10, 5, 4, 3, 1, 0, -3]);
```


## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/splice
Description: Immutable Array.prototype.splice
Author: azu
Latest version: 1.0.6

# @immutable-array/splice

Immutable [`Array.prototype.splice()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/splice).

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/splice

## Usage

Same API with [`Array.prototype.splice()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/splice).

```ts
/**
 * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
 * @param array Base array.
 * @param start The zero-based location in the array from which to start removing elements.
 * @param deleteCount The number of elements to remove.
 * @param items Elements to insert into the array in place of the deleted elements.
 */
export declare function splice<T>(array: Array<T>, start?: number, deleteCount?: number, ...items: T[]): Array<T>;
```

### Example

Delete all:

```js
import { splice } from "@immutable-array/splice"
const originalArray = ["a", "b", "c", "d", "e"];
const resultArray = splice(originalArray, 0);
assert.deepStrictEqual(resultArray, []);
```

Delete range: 1-3

```js
import { splice } from "@immutable-array/splice"
const originalArray = ["a", "b", "c", "d", "e"];
const resultArray = splice(originalArray, 1, 3);
assert.deepStrictEqual(resultArray, ["a", "e"]);
``` 

Delete and Insert = replace index 0 with "x"

```js
import { splice } from "@immutable-array/splice"
const originalArray = ["a", "b", "c", "d", "e"];
const resultArray = splice(originalArray, 0, 1, "x");
assert.deepStrictEqual(resultArray, ["x", "b", "c", "d", "e"]);
```

## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutable-array/unshift
Description: Immutable Array.prototype.unshift.
Author: azu
Latest version: 1.0.6

# @immutable-array/unshift

Immutable [`Array.prototype.unshift()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift).

## Install

Install with [npm](https://www.npmjs.com/):

    npm install @immutable-array/unshift

## Usage

Same API with [`Array.prototype.unshift()`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift).

```ts
/**
 * Inserts new elements at the start of an array.
 * @param array  base Array.
 * @param items  Elements to insert at the start of the Array.
 */
export declare function unshift<T>(array: Array<T>, ...items: T[]): Array<T>;
```

### Example

```js
import { unshift } from "@immutable-array/unshift"
const originalArray = ["a", "b", "c", "d", "e"];
const addingArray = ["f", "g"];
const resultArray = unshift(originalArray, ...addingArray);
assert.deepStrictEqual(resultArray, ["f", "g", "a", "b", "c", "d", "e"]);
```


## Changelog

See [Releases page](https://github.com/azu/immutable-array-prototype/releases).

## Running tests

Install devDependencies and Run `npm test`:

    npm i -d && npm test

## Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, [please create an issue](https://github.com/azu/immutable-array-prototype/issues).

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3. Commit your changes: `git commit -am 'Add some feature'`
4. Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Author

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## License

MIT © azu
npm package: @immutablesoft/form-edit
Description: FormAlly form editor for ReactJS, creates .json definitions for rendering with form-render.
Author: ImmutableSoft Inc.
Latest version: 0.1.4

# Getting Started

FormAlly form editor for ReactJS, creates .json definitions for rendering
with @immutablesoft/form-render. To see this library in action,
and to view documentation of supported form fields, visit
https://formally.immutablesoft.org

## Install the library

```
npm install --save @immutablesoft/form-edit
```

## Import and Use the library

This application requires React (a peerDependency of the library).
Here is an example import and basic usage. Typically the resulting 'formData'
will be used for a call to FormRender, or saved to a file for later use
with FormRender (an import from @immutablesoft/form-render).

```
import { FormEdit, FormEditToObjectArrayNoHeader } from "@immutablesoft/form-edit"

...

  const [formData, setFormData] = useState("");

  // ---------------------------------------------------------------
  // Submit button handling events for UI forms
  // ---------------------------------------------------------------
  const handleEditSubmit = (event) => { 
    event.preventDefault(); 
    const data = new FormData(event.target);

    // Without form name, parse the form and populate object array
    var formData = FormEditToObjectArrayNoHeader(data, "formally_separator_3210");

    setFormData(formData);
  };

  return (
      <div align="center">
        <FormEdit nameObj={form.formally} initialFields={form.form}
                  handleEditSubmit={handleEditSubmit} />
      </div>

```
npm package: @immutablesoft/form-render
Description: FormAlly form render from JSON definition created by form-edit for ReactJS.
Author: ImmutableSoft Inc.
Latest version: 0.1.4

# Getting Started

FormAlly form renderer of JSON form definition created by
@immutablesoft/form-edit for ReactJS. To see this library in action,
and to view documentation of supported form fields, visit
https://formally.immutablesoft.org

## Install the library

```
npm install --save @immutablesoft/form-render
```

## Import and Use the library

This application requires React (a peerDependency of the library).
Below is an example of using FormRender to render a sign up page in React.

```
import { FormRender, FormRenderToObject, FormRemoveSeparatorsAndHeader } from "@immutablesoft/form-render"

const handleSignUpSubmit = async event => {
  event.preventDefault();

  // Read and parse the submitted form data
  const rawFormData = new FormData(event.target);
  const data = FormRemoveSeparatorsAndHeader(rawFormData);
  const resultJSON = FormRenderToObject(data);

  const agree = data.get('agree');
  console.log("agree:" + agree);
  if (agree === "on")
  {
    alert("The terms were agreed upon.");

    // TODO: Submit formData 'data' to your backend server?
    //       Or save 'resultJSON' to local storage?
  }
  else
    alert("The terms must be agreeable to sign up.");
};
  
function SignUpForm(onSubmit)
{
  const formData = [{"name":"username","min":"3","max":"32","type":"text"},
                    {"name":"password","min":"5","max":"32","type":"password"},
                    {"name":"email","min":"3","max":"128","type":"email"},
                    {"name":"agreement","value":"Example EULA. Blah blah blah.","type":"display"},
                    {"name":"agree","description":"I have read and agree.","type":"checkbox"}];
  const formName = {"name":"SignUp", "version":"1.0"};
  var formStyle = {};
  formStyle.form = { color: "grey" };
  formStyle.checkbox = { align: "left" };
  formStyle.textarea = { width: "95%" };
  formStyle.input = { width: "90%" };
  formStyle.title = { display: "none" };
  formStyle.labels = { display: "none" };
  formStyle.span = { display: "none" };
  formStyle.image = { borderRadius: "50%" };

  return (<div>
            <FormRender nameObj={formName} renderFields={formData}
                        handleSubmitFunction={onSubmit} logo={null}
                        submitString={"Create Account"} style={formStyle} />
          </div>);
}

...

// Render the sign up form
SignUpForm(handleSignUpSubmit);

```