@coxy/react-validator 2.0.7 → 4.0.0

package/README.md

@@ -1,28 +1,30 @@
-### React Validator
- 
+# @Coxy/react-validator
 
-[![MIT License](https://img.shields.io/apm/l/atomic-design-ui.svg?)](https://github.com/dsshard/react-validator/blob/master/LICENSE)
-[![Travis CI](https://travis-ci.org/dsshard/react-validator.svg?branch=master)](https://travis-ci.org/dsshard/react-validator)
-[![CodeCov](https://codecov.io/gh/dsshard/react-validator/branch/master/graph/badge.svg)](https://codecov.io/gh/dsshard/react-validator)
-[![Coverage Status](https://coveralls.io/repos/github/dsshard/react-validator/badge.svg?branch=master)](https://coveralls.io/github/dsshard/react-validator?branch=master)
-[![dependencies Status](https://david-dm.org/dsshard/react-validator/status.svg)](https://david-dm.org/dsshard/react-validator)
-[![Maintainability](https://api.codeclimate.com/v1/badges/a30e71d313f2d8bdd6b1/maintainability)](https://codeclimate.com/github/dsshard/react-validator/maintainability)
-[![BundlePhobia](https://badgen.net/bundlephobia/minzip/@coxy/react-validator)](https://bundlephobia.com/result?p=@coxy/react-validator)
-[![GitHub Release](https://img.shields.io/github/release/dsshard/react-validator.svg?style=flat)]()  
+---
 
+# Simple React Form Validation
 
-Simple React form validation.
+@Coxy/react-validator provides a simple and flexible way to validate forms in React.
 
-Data validation on the **Node JS** side, is also supported.
+> Supports data validation both **in-browser** and **on Node.js**.
 
+> Requires React **\>=16.3**.
 
-Need react **>=16.3**
+---
 
-# Example
+# Installation
 
-See more examples [here](example/example.tsx)
+```bash
+npm install @coxy/react-validator
+# or
+yarn add @coxy/react-validator
+```
+
+---
+
+# Quick Start Example
 
-```jsx
+```tsx
 import React, { useState } from 'react';
 import { ValidatorWrapper, rules, ValidatorField } from '@coxy/react-validator';
 
@@ -34,174 +36,197 @@ const handleSubmit = () => {
     console.log(isValid, message, errors);
     return;
   }
-  // Success
+  alert('Form is valid!');
 };
 
-export default () => {
-  const [email, handleChange] = useState('');
+export default function Example() {
+  const [email, setEmail] = useState('');
 
   return (
     <ValidatorWrapper ref={validator}>
-
       <ValidatorField value={email} rules={rules.email}>
         {({ isValid, message }) => (
           <>
-            <input value={email} onChange={({ target: { value } }) => handleChange(value)} />
-            {!isValid && <div>{message}</div>}
+            <input value={email} onChange={({ target: { value } }) => setEmail(value)} />
+            {!isValid && <div style={{ color: 'red' }}>{message}</div>}
           </>
         )}
       </ValidatorField>
 
-      <ValidatorField value={email} rules={rules.email}>
-        <input value={email} onChange={({ target: { value } }) => handleChange(value)} />
-      </ValidatorField>
-
-      {/* This is also possible :) */}
-      <ValidatorField value={email} rules={rules.email} />
-
       <button onClick={handleSubmit} type="button">
         Submit
       </button>
-
     </ValidatorWrapper>
   );
-};
+}
 ```
 
-See more examples [here](example/example.tsx)
-&nbsp;
-# Rules
+More examples available [here](example/example.tsx).
+
+---
 
-You can create your own rules for validation, with your own error messages
+# Built-in Validation Rules
 
+Create your own rules easily, or use the built-in ones:
 
 ```javascript
 const rules = {
-  email: [{
-    rule: value => value !== '' && value.length > 0,
-    message: 'Value is required',
-  }, {
-    rule: value => value.indexOf('@') > -1,
-    message: '@ is required',
-  }]
-}
+  email: [
+    { rule: value => value.trim() !== '', message: 'Value is required' },
+    { rule: value => value.includes('@'), message: '@ is required' },
+  ],
+  password: [
+    { rule: value => value.length >= 6, message: 'Password must be at least 6 characters' },
+  ],
+  notEmpty: [
+    { rule: value => !!value && value.trim() !== '', message: 'Field cannot be empty' },
+  ],
+  boolean: [
+    { rule: value => typeof value === 'boolean', message: 'Must be a boolean value' },
+  ],
+  min: (min) => ([
+    { rule: value => Number(value) >= min, message: `Must be at least ${min}` },
+  ]),
+  max: (max) => ([
+    { rule: value => Number(value) <= max, message: `Must be at most ${max}` },
+  ]),
+  length: (min, max) => ([
+    { rule: value => value.length >= min, message: `Must be at least ${min} characters` },
+    ...(max ? [{ rule: value => value.length <= max, message: `Must be at most ${max} characters` }] : [])
+  ]),
+};
 ```
 
-This component has a default set of rules that you can use right away:
+| Name        | Type     | Description                                               |
+|-------------|----------|-----------------------------------------------------------|
+| email       | Array    | Validate non-empty email with regex check.                |
+| password    | Array    | Validate non-empty password with min length.              |
+| notEmpty    | Array    | Check if a string is not empty.                           |
+| boolean     | Array    | Ensure a boolean value is present.                        |
+| min(n)      | Function | Validate number is >= `n`.                                |
+| max(n)      | Function | Validate number is <= `n`.                                |
+| length(a,b) | Function | Validate string length is between `a` and `b` (optional). |
 
-| ****name**** | **Type** | **description**                                                         |
-|--------------|----------|-------------------------------------------------------------------------|
-| email        |          | Check email for empty string and regexp                                 |
-| password     |          | Check password for empty string and length                              |
-| notEmpty     |          | Check if the string is not empty                                        |
-| boolean      |          | Will check that the value is present                                    |
-| min          | function | min\(3\) \-> Check the number                                           |
-| max          | function | max\(5\) \-> Check the number                                           |
-| length       | function | length\(3, 5\) \-> Check string length \(second parameter is optional\) |
+---
 
-&nbsp;
+# React API
 
-# Api for React
+## `<ValidatorWrapper />` Props
 
-#### ValidatorWrapper props
+| Name             | Default | Required | Description                                        |
+|------------------|---------|----------|----------------------------------------------------|
+| ref              | null    | No       | React ref or useRef for control.                   |
+| stopAtFirstError | false   | No       | Stop validating after the first error.             |
 
-| **name**         | **default** | **required** | **description**                                        |
-|------------------|-------------|--------------|--------------------------------------------------------|
-| ref              | null        | no           | React\.ref or useRef                                   |
-| stopAtFirstError | false       | no           | The validator will stop checking after the first error |
+## `<ValidatorField />` Props
 
-&nbsp;
-#### ValidatorField props
+| Name     | Default   | Required | Description                           |
+|----------|-----------|----------|---------------------------------------|
+| value    | undefined | Yes      | Value to validate.                    |
+| rules    | []        | Yes      | Validation rules array.               |
+| required | true      | No       | Whether the field is required.        |
+| id       | null      | No       | ID for the field (for manual access). |
 
-| ****name**** | ****default**** | ****required**** | **description**               |
-|--------------|-----------------|------------------|-------------------------------|
-| value        | undefined       | yes              | Value for validation          |
-| rules        | \[\]            | yes              | Array of rules for validation |
-| required     | true            | no               | The field will be required    |
-| id           | null            | no               | ID for get field              |
+## `useValidator`
 
-&nbsp;
-# React api useValidator
+Validate a value directly in your component:
 
-```javascript
+```tsx
+import { useValidator, rules } from '@coxy/react-validator';
 
-const [isValid, { errors }] = useValidator('test value', rules.email)
-console.log(isValid, errors) // false
+const [isValid, { errors }] = useValidator('test@example.com', rules.email);
 
+console.log(isValid); // true or false
+console.log(errors);  // array of error messages
 ```
 
-&nbsp;
-# Api for inline validation
+---
 
-#### Validator constructor parameters
+# Validator Class (Node.js / Manual Usage)
 
-| **name**         | **default** | **required** | **description**                                        |
-|------------------|-------------|--------------|--------------------------------------------------------|
-| stopAtFirstError | false       | no           | The validator will stop checking after the first error |
+Use it server-side or in custom flows.
 
-&nbsp;
-#### Validator.addField()
+## Validator Constructor Options
 
-Adds a field for validation
+| Name             | Default | Required | Description                                          |
+|------------------|---------|----------|------------------------------------------------------|
+| stopAtFirstError | false   | No       | Stop validating after first error across all fields. |
 
-```javascript
-import { Validator } from '@coxy/react-validator';
+## Methods
+
+### `.addField()`
 
+```javascript
 const validator = new Validator({ stopAtFirstError: true });
+
 const field = validator.addField({
-    rules: rules.password,
-    value: '',
+  rules: rules.password,
+  value: '12345',
 });
 ```
-&nbsp;
-#### Validator.getField()
 
-Returns the field by ID
+### `.getField(id)`
 
 ```javascript
-import { Validator } from '@coxy/react-validator';
+const field = validator.getField('password-field');
+console.log(field);
+```
 
-const validator = new Validator({ stopAtFirstError: true });
-const field = validator.addField({
-    rules: rules.password,
-    value: '',
-    id: 'test-field-name'
-});
-console.log(validator.getField('test-field-name')) // Field Class
+### `.removeField(field)`
+
+```javascript
+validator.removeField(field);
 ```
-&nbsp;
-#### Validator.removeField()
 
-Removes a previously added field
+### `.validate()`
+
+```javascript
+const { isValid, message, errors } = validator.validate();
+console.log(isValid, errors);
+```
 
+## Full Server-Side Example
 
 ```javascript
-import { Validator } from '@coxy/react-validator';
+import { Validator, rules } from '@coxy/react-validator';
 
-const validator = new Validator({ stopAtFirstError: true });
-const field = validator.addField({
-    rules: rules.password,
-    value: '',
-    id: 'test-field-name'
+const validator = new Validator();
+
+validator.addField({
+  id: 'email',
+  rules: rules.email,
+  value: 'test@domain.com',
 });
 
-validator.removeField(field);
-console.log(validator.getField('test-field-name')) // null
+validator.addField({
+  id: 'password',
+  rules: rules.password,
+  value: '1234567',
+});
+
+const result = validator.validate();
+
+if (result.isValid) {
+  console.log('Validation passed!');
+} else {
+  console.error('Validation failed:', result.errors);
+}
 ```
 
-&nbsp;
-#### Validator.validate()
+---
 
-Validates all added fields
+# License
 
-```javascript
-import { Validator } from '@coxy/react-validator';
+MIT © [Dsshard](https://github.com/dsshard)
 
-const validator = new Validator({ stopAtFirstError: true });
-const field = validator.addField({
-    rules: rules.password,
-    value: '',
-});
+---
+
+# Notes
+
+- Lightweight, flexible, easy to integrate.
+- Server-side and client-side validation supported.
+- Create custom rules for different scenarios.
+- Easy to add dynamic validation logic.
+
+> **Fun Fact:** Early validation of user inputs in a form can reduce backend server load by up to **40%** compared to server-only validation!
 
-console.log(validator.validate());
-```

package/biome.json

@@ -0,0 +1,34 @@
+{
+  "files": {
+    "includes": ["src/**/*", "example/example.tsx"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 120,
+    "formatWithErrors": false
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "semicolons": "asNeeded",
+      "trailingCommas": "all"
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "json": {
+    "formatter": {
+      "indentStyle": "space",
+      "indentWidth": 2
+    },
+    "linter": {
+      "enabled": true
+    }
+  }
+}

package/dist/index.d.mts

@@ -0,0 +1,106 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+type Value = any;
+type Fn$1 = (validity: Validity, value: Value) => ReactNode;
+declare const ValidatorField: react.ForwardRefExoticComponent<FieldParams & {
+    children?: ReactNode | Fn$1;
+} & react.RefAttributes<unknown>>;
+
+type Fn = (value: Value) => string;
+interface ValidatorRule {
+    rule: (value: Value) => boolean;
+    message: string | Fn;
+}
+interface ErrorMessage {
+    message: string;
+    isValid: boolean;
+}
+interface Validity {
+    message: string;
+    isValid: boolean;
+    errors?: ErrorMessage[];
+    id?: string | number;
+}
+interface FieldParams {
+    value: Value;
+    rules: ValidatorRules;
+    required?: boolean;
+    id?: string | number;
+}
+
+type ValidatorRules = ValidatorRule[];
+declare const rules: {
+    notEmpty: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    bool: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    password: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    email: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    min: (min: number) => {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    max: (max: number) => {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    length: (min: number, max?: number) => {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+};
+
+declare function useValidator(value: Value, rules: ValidatorRules): [boolean, Pick<Validity, 'message' | 'errors'>];
+
+declare class Field {
+    protected rules: ValidatorRules;
+    protected required: boolean;
+    protected value: Value;
+    id: string | number;
+    constructor({ rules, required, value, id }: FieldParams);
+    validate(): Validity;
+}
+interface ValidatorParams {
+    stopAtFirstError: boolean;
+}
+declare class Validator {
+    private fields;
+    private params;
+    constructor(params?: ValidatorParams);
+    addField(params: FieldParams): Field;
+    removeField(field: Field): void;
+    getField(id: Field['id']): Field;
+    validate(): Validity;
+}
+
+interface RegisteredFieldHandle {
+    props: FieldParams;
+    validate: () => Validity;
+}
+
+interface ComponentProps {
+    children?: ReactNode;
+    stopAtFirstError?: boolean;
+}
+interface ValidatorWrapper {
+    validate: () => Validity;
+    getField: (id: string | number) => RegisteredFieldHandle | null;
+    registerField: (field: RegisteredFieldHandle) => void;
+    unregisterField: (field: RegisteredFieldHandle) => void;
+    setCustomError: (customError: Validity) => void;
+    clearCustomErrors: () => void;
+}
+declare const ValidatorWrapper: react.ForwardRefExoticComponent<ComponentProps & react.RefAttributes<ValidatorWrapper>>;
+
+export { type ErrorMessage, type FieldParams, Validator, ValidatorField, type ValidatorRule, ValidatorWrapper, type Validity, rules, useValidator };

package/dist/index.d.ts

@@ -1,6 +1,106 @@
-export { rules } from './rules';
-export { ValidatorField } from './validator-field';
-export { ValidatorWrapper } from './validator-wrapper';
-export { Validator } from './validator';
-export { useValidator } from './use-validator';
-export * from './types';
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+type Value = any;
+type Fn$1 = (validity: Validity, value: Value) => ReactNode;
+declare const ValidatorField: react.ForwardRefExoticComponent<FieldParams & {
+    children?: ReactNode | Fn$1;
+} & react.RefAttributes<unknown>>;
+
+type Fn = (value: Value) => string;
+interface ValidatorRule {
+    rule: (value: Value) => boolean;
+    message: string | Fn;
+}
+interface ErrorMessage {
+    message: string;
+    isValid: boolean;
+}
+interface Validity {
+    message: string;
+    isValid: boolean;
+    errors?: ErrorMessage[];
+    id?: string | number;
+}
+interface FieldParams {
+    value: Value;
+    rules: ValidatorRules;
+    required?: boolean;
+    id?: string | number;
+}
+
+type ValidatorRules = ValidatorRule[];
+declare const rules: {
+    notEmpty: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    bool: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    password: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    email: {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    min: (min: number) => {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    max: (max: number) => {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+    length: (min: number, max?: number) => {
+        rule: (value: string) => boolean;
+        message: string;
+    }[];
+};
+
+declare function useValidator(value: Value, rules: ValidatorRules): [boolean, Pick<Validity, 'message' | 'errors'>];
+
+declare class Field {
+    protected rules: ValidatorRules;
+    protected required: boolean;
+    protected value: Value;
+    id: string | number;
+    constructor({ rules, required, value, id }: FieldParams);
+    validate(): Validity;
+}
+interface ValidatorParams {
+    stopAtFirstError: boolean;
+}
+declare class Validator {
+    private fields;
+    private params;
+    constructor(params?: ValidatorParams);
+    addField(params: FieldParams): Field;
+    removeField(field: Field): void;
+    getField(id: Field['id']): Field;
+    validate(): Validity;
+}
+
+interface RegisteredFieldHandle {
+    props: FieldParams;
+    validate: () => Validity;
+}
+
+interface ComponentProps {
+    children?: ReactNode;
+    stopAtFirstError?: boolean;
+}
+interface ValidatorWrapper {
+    validate: () => Validity;
+    getField: (id: string | number) => RegisteredFieldHandle | null;
+    registerField: (field: RegisteredFieldHandle) => void;
+    unregisterField: (field: RegisteredFieldHandle) => void;
+    setCustomError: (customError: Validity) => void;
+    clearCustomErrors: () => void;
+}
+declare const ValidatorWrapper: react.ForwardRefExoticComponent<ComponentProps & react.RefAttributes<ValidatorWrapper>>;
+
+export { type ErrorMessage, type FieldParams, Validator, ValidatorField, type ValidatorRule, ValidatorWrapper, type Validity, rules, useValidator };

package/dist/index.js

@@ -1,28 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useValidator = exports.Validator = exports.ValidatorWrapper = exports.ValidatorField = exports.rules = void 0;
-var rules_1 = require("./rules");
-Object.defineProperty(exports, "rules", { enumerable: true, get: function () { return rules_1.rules; } });
-var validator_field_1 = require("./validator-field");
-Object.defineProperty(exports, "ValidatorField", { enumerable: true, get: function () { return validator_field_1.ValidatorField; } });
-var validator_wrapper_1 = require("./validator-wrapper");
-Object.defineProperty(exports, "ValidatorWrapper", { enumerable: true, get: function () { return validator_wrapper_1.ValidatorWrapper; } });
-var validator_1 = require("./validator");
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return validator_1.Validator; } });
-var use_validator_1 = require("./use-validator");
-Object.defineProperty(exports, "useValidator", { enumerable: true, get: function () { return use_validator_1.useValidator; } });
-__exportStar(require("./types"), exports);
+'use strict';var react=require('react'),jsxRuntime=require('react/jsx-runtime');var h=/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,x={notEmpty:[{rule:r=>r!==""&&r.length>0,message:"Value is required"}],bool:[{rule:r=>!!r,message:"Value is required"}],password:[{rule:r=>r.length>0,message:"Password field cannot be empty"},{rule:r=>r.length>5,message:"Password field can not be less than 6 characters"}],email:[{rule:r=>!!r&&r!==""&&r.length!==0,message:"Email is required"},{rule:r=>h.test(String(r).toLowerCase()),message:"Email is invalid"}],min:r=>[{rule:e=>Number.parseFloat(e)>r,message:`The value must be greater than ${r}`}],max:r=>[{rule:e=>Number.parseFloat(e)<r,message:`The value must be smaller ${r}`}],length:(r,e)=>[{rule:t=>String(t).length>=r,message:`No less than ${r} symbols`},{rule:t=>e!==void 0?String(t).length<=e:true,message:`No more than ${e} symbols`}]};var V=class{rules;required;value;id;constructor({rules:e,required:t,value:s,id:i}){this.rules=e,this.required=t,this.value=s,this.id=i;}validate(){let e=true,t="",{rules:s,value:i,required:d,id:u}=this,n=!i&&Number.parseFloat(i)!==0;if(!s.length||n&&d===false)return {isValid:e,message:t,id:u};for(let a of s)e&&(e=a.rule(i),e||(typeof a.message=="function"?t=a.message(i):t=a.message));return {isValid:e,message:t,id:u}}},c=class{fields;params;constructor(e){this.params=e||null,this.fields=[];}addField(e){let t=new V(e);return this.fields.push(t),t}removeField(e){let t=this.fields.indexOf(e);t>-1&&this.fields.splice(t,1);}getField(e){return this.fields.find(t=>t.id===e)||null}validate(){let e,s=this.fields.map(i=>this.params?.stopAtFirstError&&e&&e.isValid===false?null:(e=i.validate(),e)).filter(i=>i&&i.isValid===false);if(s.length){let{isValid:i,message:d}=s[0];return {isValid:i,message:d,errors:s}}return {isValid:true,message:""}}};function b(r,e){let t=new c;t.addField({value:r,rules:e});let{isValid:s,...i}=t.validate();return [s,i]}var v=react.createContext(null);var w=react.forwardRef(function(e,t){let{children:s,value:i}=e,{customErrors:d,registerField:u,unregisterField:n}=react.useContext(v),a=react.useRef(e);a.current=e;let g=react.useRef(d);g.current=d;let p=react.useRef(null);p.current||(p.current={get props(){return a.current},validate:()=>{let m=a.current,y=g.current.find(o=>o.id===m.id);return y||new V({rules:m.rules,required:m.required,value:m.value,id:m.id}).validate()}}),react.useEffect(()=>(u(p.current),()=>{n(p.current);}),[u,n]);let F=p.current.validate();return typeof s=="function"?s(F,i):s});var S=react.forwardRef(function({children:e,stopAtFirstError:t},s){let i=react.useRef([]),[d,u]=react.useState([]),n=react.useCallback(l=>{l&&!i.current.includes(l)&&i.current.push(l);},[]),a=react.useCallback(l=>{let o=i.current.indexOf(l);o>-1&&i.current.splice(o,1);},[]),g=react.useCallback(l=>i.current.find(o=>o?.props?.id===l)||null,[]),p=react.useCallback(l=>{u(o=>[...o,l]);},[]),F=react.useCallback(()=>{u([]);},[]),m=react.useCallback(()=>{let l=new c({stopAtFirstError:t});for(let o of i.current)l.addField(o.props);return l.validate()},[t]);react.useImperativeHandle(s,()=>({validate:m,getField:g,registerField:n,unregisterField:a,setCustomError:p,clearCustomErrors:F}),[m,g,n,a,p,F]);let y=react.useMemo(()=>({customErrors:d,registerField:n,unregisterField:a}),[d,n,a]);return jsxRuntime.jsx(v.Provider,{value:y,children:e})});exports.Validator=c;exports.ValidatorField=w;exports.ValidatorWrapper=S;exports.rules=x;exports.useValidator=b;//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map