jis 2.0.2 → 2.1.0-preview.1

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## [Unreleased]
+
+### Deprecated
+- Accessing type checks directly via `jis.is` and `jis.$*` is deprecated.
+  These APIs will be removed in v3.0.0.
+  Use `jis.types.*` and `jis.semantic.*` instead.
+
+### Added
+- Introduced new namespaces: `jis.types` and `jis.semantic`
+
+## [2.0.2]
+### Fixed
+- Fixed CI configuration to run `build` and `test` jobs only on merge requests to `dev` and `master`
+- Fixed package publishing issue where the `dist/` folder was not included
+
+## [2.0.1]
+### Changed
+- Migrated build system from webpack to Vite
+- Integrated Vitest
+- Integrated CI/CD (build, test, and deploy)
+
+### Notes
+- Previous versions (< 2.0.1) were early iterations and did not follow a formal changelog.

package/README.md

@@ -1,242 +1,297 @@
 # J`is`
 
-`jis` is a data type verifier for older browsers. Based in `Object.prototype.toString.call`
+`jis` is a lightweight runtime data type verifier designed for browsers and environments where static typing or modern language features may not be reliable or available.
 
-The library has some methods to check the data type.
+Based on `Object.prototype.toString.call`, the library provides a set of methods to perform reliable runtime data type checks.
+
+### Why jis?
+
+`jis` comes from `is`, the core of the library, prefixed with `j` (my initial).
+Phonetically, it sounds like “ji-is”, a subtle nod to JS itself.
+
+In the browser, everything runs as JavaScript at runtime.
+Static types disappear after transpilation, and runtime type checks are often limited, inconsistent, or dependent on modern language features that are not always available.
+
+`jis` focuses on providing simple, reliable runtime `is` checks using the most stable and widely supported mechanisms in JavaScript.
  
  ### Installation
- 
- ```shell script
-npm install jis
-```
 
-You can install this library with `npm` or `yarn`. And you can add in `devDependecies` with
+You can install this library with npm or yarn.
 
-```shell script
-npm install jis --dev
+ ```shell script
+npm install jis
 ```
 
 ### Usage
 
-##### Import in ES5 or higher
+#### Import in ES5 or higher
 
 ```js
-let jis = require('jis')
+const jis = require('jis')
 ```
 
-##### Import in TS
+#### Import in TS
 
 ```ts
 import jis from 'jis'
 ```
 
-#### Methods
+### ⚠️ Backward compatibility
 
-##### $array
+In `v2.x`, legacy access via `jis.is` and `jis.$*` **still works for compatibility reasons**, but it is **deprecated** and will be removed in `v3.0.0`.
 
-```js
-
-jis.$array( [] ) // true
-
-jis.$array( true ) //false
-jis.$array( function() {} ) // false
-jis.$array( null ) // false
-jis.$array( 12 ) // false
-jis.$array( {} ) // false
-jis.$array( '' ) // false
-jis.$array( undefined ) // false
+If you are starting a new project or updating existing code, **use the new namespaces shown below**.
 
+```js
+// Deprecated
+jis.is(arg, type);
+jis.$object(arg);
+jis.$array(arg);
+jis.$number(arg);
+jis.$string(arg);
+jis.$boolean(arg);
+jis.$undefined(arg);
+jis.$function(arg);
+jis.$null(arg);
+
+jis.$empty(arg);
+jis.$numeric(arg);
+jis.$primitive(arg);
 ```
 
-##### $boolean
+Use the new namespaces instead:
 
 ```js
+jis.types.is(arg, type);
+jis.types.$object(arg);
+jis.types.$array(arg);
+jis.types.$number(arg);
+jis.types.$string(arg);
+jis.types.$boolean(arg);
+jis.types.$undefined(arg);
+jis.types.$function(arg);
+jis.types.$null(arg);
+
+jis.semantic.$empty(arg);
+jis.semantic.$numeric(arg);
+jis.semantic.$primitive(arg);
+```
 
-jis.$boolean( true ) // true
-jis.$boolean( false ) // true
+## API
 
-jis.$boolean( [] ) //false
-jis.$boolean( function() {} ) // false
+### Type checks (`jis.types`)
+#### $array
 
-// ...
+```js
+const { $array } = jis.types // jis.types.$array
+
+$array( [] ) // true
 
+$array( true ) // false
+$array( function() {} ) // false
+$array( null ) // false
+$array( 12 ) // false
+$array( {} ) // false
+$array( '' ) // false
+$array( undefined ) // false
 ```
 
-##### $function
+#### $boolean
 
 ```js
+const { $boolean } = jis.types
 
-jis.$function( function() {} ) // true
+$boolean( true ) // true
+$boolean( false ) // true
 
-jis.$function( 12 ) // false
-jis.$function( {} ) // false
-jis.$function( '' ) // false
+$boolean( [] ) // false
+$boolean( function() {} ) // false
 
 // ...
-
 ```
 
-##### $null
+#### $function
 
 ```js
+const { $function } = jis.types
 
-jis.$null( null ) // true
+$function( function() {} ) // true
 
-jis.$null( {} ) // false
-jis.$null( '' ) // false
-jis.$null( undefined ) // false
+$function( 12 ) // false
+$function( {} ) // false
+$function( '' ) // false
 
 // ...
-
 ```
 
-##### $number
+#### $null
 
 ```js
+const { $null } = jis.types
 
-jis.$number( 12 ) // true
+$null( null ) // true
 
-jis.$number( function() {} ) // false
-jis.$number( null ) // false
-jis.$number( undefined ) // false
+$null( {} ) // false
+$null( '' ) // false
+$null( undefined ) // false
 
 // ...
-
 ```
 
-##### $object
+#### $number
 
 ```js
+const { $number } = jis.types
 
-jis.$object( {} ) // true
+$number( 12 ) // true
 
-jis.$object( [] ) // false
-jis.$object( true ) //false
-jis.$object( 12 ) // false
+$number( function() {} ) // false
+$number( null ) // false
+$number( undefined ) // false
 
 // ...
-
 ```
 
-##### $string
+#### $object
 
 ```js
+const { $object } = jis.types
 
-jis.$string( 'Some text' ) // true
+$object( {} ) // true
 
-jis.$string( [] ) // false
-jis.$string( true ) //false
-jis.$string( undefined ) // false
+$object( [] ) // false
+$object( true ) // false
+$object( 12 ) // false
 
 // ...
-
 ```
 
-##### $undefined
+#### $string
 
 ```js
+const { $string } = jis.types
 
-jis.$undefined( undefined ) // true
+$string( 'Some text' ) // true
 
-jis.$undefined( [] ) // false
-jis.$undefined( {} ) // false
-jis.$undefined( '' ) // false
+$string( [] ) // false
+$string( true ) // false
+$string( undefined ) // false
 
 // ...
-
 ```
 
-##### $numeric
-
-Check if the argument is a number or number string (including exponential)
+#### $undefined
 
 ```js
+const { $undefined } = jis.types
 
-jis.$numeric( 12 ) // true
-jis.$numeric( '12' ) // true
-jis.$numeric( '-12' ) // true
-jis.$numeric( '+12' ) // true
-jis.$numeric( '12.' ) // true
-jis.$numeric( '12.e5' ) // true
-jis.$numeric( '12.E5' ) // true
-jis.$numeric( '12.E-5' ) // true
-jis.$numeric( '-12.E-5' ) // true
-jis.$numeric( '+12.E-5' ) // true
+$undefined( undefined ) // true
 
-jis.$numeric( '12.E-' ) // false
-jis.$numeric( 'A3B' ) // false
-jis.$numeric( undefined ) // false
-jis.$numeric( null ) // false
+$undefined( [] ) // false
+$undefined( {} ) // false
+$undefined( '' ) // false
 
+// ...
 ```
 
-##### $primitive
+#### is
 
-Check if the argument is primitive type
+This method is the core of the library and provides more flexible and advanced type checks.
 
 ```js
+const { is } = jis.types
+
+is( [], 'Array' ) // true
+is( false, 'Boolean' ) // true
+is( true, 'Boolean' ) // true
+is( function(){}, 'Function' ) // true
+is( null, 'Null' ) // true
+is( 12, 'Number' ) // true
+is( {}, 'Object' ) // true
+is( 'Text', 'String' ) // true
+is( undefined, 'Undefined' ) // true
 
-jis.$primitive(undefined) // true
-jis.$primitive(null) // true
-jis.$primitive("something") // true
-jis.$primitive(true) // true
-jis.$primitive(false) // true
-jis.$primitive(12) // true
-jis.$primitive(Symbol()) // true
+let date = new Date();
+is(date, Date) // true
 
-jis.$primitive({}) // false
-jis.$primitive([]) // false
-jis.$primitive(new Date()) // false
+is(/^$/g, RegExp) // true
+is(/^$/g, 'RegExp') // true
 
-```
+is(12, 12) // true
+is(12, 13) // false
 
-##### $empty
-
-```js
+// ... experiment with this method :D
+```
 
-jis.$empty(null) // true
-jis.$empty(undefined) // true
-jis.$empty(false) // true
-jis.$empty(0) // true
-jis.$empty(0.0) // true
-jis.$empty("") // true
-jis.$empty("0") // true
-jis.$empty([]) // true
+### Semantic checks (`jis.semantic`)
+#### $numeric
 
-jis.$empty(true) // false
-jis.$empty(12) // false
-jis.$empty(12.0) // false
-jis.$empty("something") // false
-jis.$empty("012") // false
-jis.$empty([1, 2, 3]) // false
+Check if the argument is a number or number string (including exponential)
 
+```js
+const { $numeric } = jis.semantic // jis.semantic.$numeric
+
+$numeric( 12 ) // true
+$numeric( '12' ) // true
+$numeric( '-12' ) // true
+$numeric( '+12' ) // true
+$numeric( '12.' ) // true
+$numeric( '12.e5' ) // true
+$numeric( '12.E5' ) // true
+$numeric( '12.E-5' ) // true
+$numeric( '-12.E-5' ) // true
+$numeric( '+12.E-5' ) // true
+
+$numeric( '12.E-' ) // false
+$numeric( 'A3B' ) // false
+$numeric( undefined ) // false
+$numeric( null ) // false
 ```
 
-##### is
+#### $primitive
 
-This method is the library core. Have more options.
+Check if the argument is a primitive value
 
 ```js
+const { $primitive } = jis.semantic
+
+$primitive(undefined) // true
+$primitive(null) // true
+$primitive("something") // true
+$primitive(true) // true
+$primitive(false) // true
+$primitive(12) // true
+$primitive(Symbol()) // true
+
+$primitive({}) // false
+$primitive([]) // false
+$primitive(new Date()) // false
+```
 
-jis.is( [], 'Array' ) // true
-jis.is( false, 'Boolean' ) // true
-jis.is( true, 'Boolean' ) // true
-jis.is( function(){}, 'Function' ) // true
-jis.is( null, 'Null' ) // true
-jis.is( 12, 'Number' ) // true
-jis.is( {}, 'Object' ) // true
-jis.is( 'Text', 'String' ) // true
-jis.is( undefined, 'Undefined' ) // true
-
-let date = new Date();
-jis.is(date, Date) // true
+#### $empty
 
-jis.is(/^$/g, RegExp) // true
-jis.is(/^$/g, 'RegExp') // true
+$empty follows a semantic definition of emptiness, where certain falsy or zero-like values are intentionally considered empty.
 
-jis.is(12, 12) // true
-jis.is(12, 13) // false
+```js
+const { $empty } = jis.semantic
+
+$empty(null) // true
+$empty(undefined) // true
+$empty(false) // true
+$empty(0) // true
+$empty(0.0) // true
+$empty("") // true
+$empty("0") // true
+$empty([]) // true
+
+$empty(true) // false
+$empty(12) // false
+$empty(12.0) // false
+$empty("something") // false
+$empty("012") // false
+$empty([1, 2, 3]) // false
+```
 
-// ... experiment with this method :D
+## Changelog
 
-```
+See [CHANGELOG.md](./CHANGELOG.md) for version history and breaking changes.

package/dist/Is.d.ts

@@ -1,4 +1,4 @@
-import { Gen } from './interfaces/main.ts';
+import { IGen } from './interfaces/main.ts';
 export default class Is {
     private static callToString;
     static $string(arg: any): boolean;
@@ -10,8 +10,5 @@ export default class Is {
     static $undefined(arg: any): boolean;
     static $boolean(arg: any): boolean;
     static $function(arg: any): boolean;
-    static objectIsValid(data: Gen, rules: Gen): boolean;
-    static $numeric(arg: any): boolean;
-    static $primitive(arg: any): boolean;
-    static $empty(arg: any): boolean;
+    static objectIsValid(data: IGen, rules: IGen): boolean;
 }

package/dist/Semantic.d.ts

@@ -0,0 +1,5 @@
+export default class Semantic {
+    static $numeric(arg: any): boolean;
+    static $primitive(arg: any): boolean;
+    static $empty(arg: any): boolean;
+}

package/dist/interfaces/ILegacyApi.d.ts

@@ -0,0 +1,28 @@
+import { default as Is } from '../Is';
+import { default as Semantic } from '../Semantic.ts';
+export default interface ILegacyApi {
+    /** @deprecated Use `jis.types.is`. It'll be remove in v3.0.0 **/
+    is: typeof Is.is;
+    /** @deprecated Use `jis.types.$object`. It'll be remove in v3.0.0 **/
+    $object: typeof Is.$object;
+    /** @deprecated Use `jis.types.$array`. It'll be remove in v3.0.0 **/
+    $array: typeof Is.$array;
+    /** @deprecated Use `jis.types.$number`. It'll be remove in v3.0.0 **/
+    $number: typeof Is.$number;
+    /** @deprecated Use `jis.types.$string`. It'll be remove in v3.0.0 **/
+    $string: typeof Is.$string;
+    /** @deprecated Use `jis.types.$boolean`. It'll be remove in v3.0.0 **/
+    $boolean: typeof Is.$boolean;
+    /** @deprecated Use `jis.types.$undefined`. It'll be remove in v3.0.0 **/
+    $undefined: typeof Is.$undefined;
+    /** @deprecated Use `jis.types.$function`. It'll be remove in v3.0.0 **/
+    $function: typeof Is.$function;
+    /** @deprecated Use `jis.types.$null`. It'll be remove in v3.0.0 **/
+    $null: typeof Is.$null;
+    /** @deprecated Use `jis.semantic.$empty`. It'll be remove in v3.0.0 **/
+    $empty: typeof Semantic.$empty;
+    /** @deprecated Use `jis.semantic.$numeric`. It'll be remove in v3.0.0 **/
+    $numeric: typeof Semantic.$numeric;
+    /** @deprecated Use `jis.semantic.$primitive`. It'll be remove in v3.0.0 **/
+    $primitive: typeof Semantic.$primitive;
+}

package/dist/interfaces/main.d.ts

@@ -1,3 +1,3 @@
-export interface Gen extends Object {
+export interface IGen extends Object {
     [key: string]: any;
 }

package/dist/jis.js

@@ -1,76 +1,111 @@
-class e {
-  static callToString(t) {
-    return Object.prototype.toString.call(t);
+class t {
+  static callToString(e) {
+    return Object.prototype.toString.call(e);
   }
-  static $string(t) {
-    return e.callToString(t) === "[object String]";
+  static $string(e) {
+    return t.callToString(e) === "[object String]";
   }
-  static is(t, n) {
-    return e.$function(n) ? t instanceof n : e.$string(n) ? e.callToString(t) === `[object ${n}]` : t === n;
+  static is(e, r) {
+    return t.$function(r) ? e instanceof r : t.$string(r) ? t.callToString(e) === `[object ${r}]` : e === r;
   }
-  static $array(t) {
-    return e.is(t, "Array");
+  static $array(e) {
+    return t.is(e, "Array");
   }
-  static $null(t) {
-    return e.is(t, "Null");
+  static $null(e) {
+    return t.is(e, "Null");
   }
-  static $number(t) {
-    return e.is(t, "Number");
+  static $number(e) {
+    return t.is(e, "Number");
   }
-  static $object(t) {
-    return e.is(t, "Object");
+  static $object(e) {
+    return t.is(e, "Object");
   }
-  static $undefined(t) {
-    return e.is(t, "Undefined");
+  static $undefined(e) {
+    return t.is(e, "Undefined");
   }
-  static $boolean(t) {
-    return e.is(t, "Boolean");
+  static $boolean(e) {
+    return t.is(e, "Boolean");
   }
-  static $function(t) {
-    return e.callToString(t) === "[object Function]";
+  static $function(e) {
+    return t.callToString(e) === "[object Function]";
   }
-  static objectIsValid(t, n) {
-    if (!e.$object(t)) throw new Error("The data parameter must be an Object");
-    if (!e.$object(n)) throw new Error("The rules parameter must be an Object");
-    let r = !0;
-    return Object.getOwnPropertyNames(n).forEach((a) => {
-      let i = n[a];
-      if (e.$array(i)) {
-        if (i.length < 1) return;
-        let l = !1;
-        return i.forEach((o) => {
-          l = l || e.is(t[a], o);
-        }), r = r && l;
+  static objectIsValid(e, r) {
+    if (!t.$object(e)) throw new Error("The data parameter must be an Object");
+    if (!t.$object(r)) throw new Error("The rules parameter must be an Object");
+    let n = !0;
+    return Object.getOwnPropertyNames(r).forEach((i) => {
+      let a = r[i];
+      if (t.$array(a)) {
+        if (a.length < 1) return;
+        let o = !1;
+        return a.forEach((s) => {
+          o = o || t.is(e[i], s);
+        }), n = n && o;
       }
-      r = r && e.is(t[a], i);
-    }), r;
+      n = n && t.is(e[i], a);
+    }), n;
   }
-  static $numeric(t) {
-    if (e.$number(t))
-      return !0;
-    let n = String(t || "");
-    return /^[-+]?(([0-9]+)|([0-9]*(\.[0-9]+))|([0-9]+\.))([Ee]([-+]?[0-9]+))?$/g.test(n);
+}
+class l {
+  static $numeric(e) {
+    return [
+      t.$number,
+      (n) => {
+        let c = String(n || "");
+        return /^[-+]?(([0-9]+)|([0-9]*(\.[0-9]+))|([0-9]+\.))([Ee]([-+]?[0-9]+))?$/g.test(c);
+      }
+    ].some((n) => n(e));
   }
-  static $primitive(t) {
+  static $primitive(e) {
     return [
-      e.$undefined,
-      e.$null,
-      e.$boolean,
-      e.$number,
-      e.$string,
-      (r) => e.is(r, "Symbol")
-    ].some((r) => r(t));
+      t.$undefined,
+      t.$null,
+      t.$boolean,
+      t.$number,
+      t.$string,
+      (n) => t.is(n, "Symbol")
+    ].some((n) => n(e));
   }
-  static $empty(t) {
+  static $empty(e) {
     return [
-      e.$undefined,
-      e.$null,
-      (r) => e.$boolean(r) && !r,
-      (r) => e.$number(r) && r === 0,
-      (r) => (e.$array(r) || e.$string(r)) && (r === "0" || r.length === 0)
-    ].some((r) => r(t));
+      t.$undefined,
+      t.$null,
+      (n) => t.$boolean(n) && !n,
+      (n) => t.$number(n) && n === 0,
+      (n) => (t.$array(n) || t.$string(n)) && (n === "0" || n.length === 0)
+    ].some((n) => n(e));
   }
 }
+const {
+  is: $,
+  $array: u,
+  $object: b,
+  $number: m,
+  $string: f,
+  $boolean: d,
+  $undefined: j,
+  $function: g,
+  $null: p
+} = t, {
+  $primitive: S,
+  $empty: h,
+  $numeric: v
+} = l, O = {
+  types: t,
+  semantic: l,
+  is: $,
+  $object: b,
+  $array: u,
+  $number: m,
+  $string: f,
+  $boolean: d,
+  $undefined: j,
+  $function: g,
+  $null: p,
+  $empty: h,
+  $numeric: v,
+  $primitive: S
+};
 export {
-  e as default
+  O as default
 };

package/dist/jis.umd.cjs

@@ -1 +1 @@
-(function(t,o){typeof exports=="object"&&typeof module<"u"?module.exports=o():typeof define=="function"&&define.amd?define(o):(t=typeof globalThis<"u"?globalThis:t||self,t.jis=o())})(this,(function(){"use strict";class t{static callToString(e){return Object.prototype.toString.call(e)}static $string(e){return t.callToString(e)==="[object String]"}static is(e,r){return t.$function(r)?e instanceof r:t.$string(r)?t.callToString(e)===`[object ${r}]`:e===r}static $array(e){return t.is(e,"Array")}static $null(e){return t.is(e,"Null")}static $number(e){return t.is(e,"Number")}static $object(e){return t.is(e,"Object")}static $undefined(e){return t.is(e,"Undefined")}static $boolean(e){return t.is(e,"Boolean")}static $function(e){return t.callToString(e)==="[object Function]"}static objectIsValid(e,r){if(!t.$object(e))throw new Error("The data parameter must be an Object");if(!t.$object(r))throw new Error("The rules parameter must be an Object");let n=!0;return Object.getOwnPropertyNames(r).forEach(u=>{let i=r[u];if(t.$array(i)){if(i.length<1)return;let l=!1;return i.forEach(a=>{l=l||t.is(e[u],a)}),n=n&&l}n=n&&t.is(e[u],i)}),n}static $numeric(e){if(t.$number(e))return!0;let r=String(e||"");return/^[-+]?(([0-9]+)|([0-9]*(\.[0-9]+))|([0-9]+\.))([Ee]([-+]?[0-9]+))?$/g.test(r)}static $primitive(e){return[t.$undefined,t.$null,t.$boolean,t.$number,t.$string,n=>t.is(n,"Symbol")].some(n=>n(e))}static $empty(e){return[t.$undefined,t.$null,n=>t.$boolean(n)&&!n,n=>t.$number(n)&&n===0,n=>(t.$array(n)||t.$string(n))&&(n==="0"||n.length===0)].some(n=>n(e))}}return t}));
+(function(t,r){typeof exports=="object"&&typeof module<"u"?module.exports=r():typeof define=="function"&&define.amd?define(r):(t=typeof globalThis<"u"?globalThis:t||self,t.jis=r())})(this,(function(){"use strict";class t{static callToString(e){return Object.prototype.toString.call(e)}static $string(e){return t.callToString(e)==="[object String]"}static is(e,i){return t.$function(i)?e instanceof i:t.$string(i)?t.callToString(e)===`[object ${i}]`:e===i}static $array(e){return t.is(e,"Array")}static $null(e){return t.is(e,"Null")}static $number(e){return t.is(e,"Number")}static $object(e){return t.is(e,"Object")}static $undefined(e){return t.is(e,"Undefined")}static $boolean(e){return t.is(e,"Boolean")}static $function(e){return t.callToString(e)==="[object Function]"}static objectIsValid(e,i){if(!t.$object(e))throw new Error("The data parameter must be an Object");if(!t.$object(i))throw new Error("The rules parameter must be an Object");let n=!0;return Object.getOwnPropertyNames(i).forEach(o=>{let a=i[o];if(t.$array(a)){if(a.length<1)return;let c=!1;return a.forEach(S=>{c=c||t.is(e[o],S)}),n=n&&c}n=n&&t.is(e[o],a)}),n}}class r{static $numeric(e){return[t.$number,n=>{let s=String(n||"");return/^[-+]?(([0-9]+)|([0-9]*(\.[0-9]+))|([0-9]+\.))([Ee]([-+]?[0-9]+))?$/g.test(s)}].some(n=>n(e))}static $primitive(e){return[t.$undefined,t.$null,t.$boolean,t.$number,t.$string,n=>t.is(n,"Symbol")].some(n=>n(e))}static $empty(e){return[t.$undefined,t.$null,n=>t.$boolean(n)&&!n,n=>t.$number(n)&&n===0,n=>(t.$array(n)||t.$string(n))&&(n==="0"||n.length===0)].some(n=>n(e))}}const{is:u,$array:l,$object:$,$number:f,$string:b,$boolean:d,$undefined:m,$function:p,$null:j}=t,{$primitive:g,$empty:h,$numeric:y}=r;return{types:t,semantic:r,is:u,$object:$,$array:l,$number:f,$string:b,$boolean:d,$undefined:m,$function:p,$null:j,$empty:h,$numeric:y,$primitive:g}}));

package/dist/main.d.ts

@@ -1,2 +1,8 @@
 import { default as Is } from './Is.ts';
-export default Is;
+import { default as ILegacyApi } from './interfaces/ILegacyApi.ts';
+import { default as Semantic } from './Semantic.ts';
+declare const api: ILegacyApi & {
+    types: typeof Is;
+    semantic: typeof Semantic;
+};
+export default api;

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "jis",
   "private": false,
-  "version": "2.0.2",
+  "version": "2.1.0-preview.1",
   "description": "When you need validate the variable data type",
   "type": "module",
   "main": "./dist/jis.umd.cjs",
   "module": "./dist/jis.js",
   "types": "./dist/main.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "exports": {
     ".": {