hono 1.3.4 → 1.4.0

package/dist/router/reg-exp-router/router.js

@@ -64,6 +64,14 @@ function compareRoute(a, b) {
     }
     return i === b.hint.regExpComponents.length || a.hint.endWithWildcard ? 1 : 0;
 }
+function compareHandler(a, b) {
+    return a.componentsLength !== b.componentsLength
+        ? a.componentsLength - b.componentsLength
+        : a.index - b.index;
+}
+function getSortedHandlers(handlers) {
+    return [...handlers].sort(compareHandler).map((h) => h.handler);
+}
 function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
     const trie = new trie_1.Trie({ reverse: hasAmbiguous });
     const handlers = [];
@@ -76,6 +84,9 @@ function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
             [...routes[i].middleware, ...routes[i].handlers],
             Object.keys(paramMap).length !== 0 ? paramMap : null,
         ];
+        if (!hasAmbiguous) {
+            handlers[i][0] = getSortedHandlers(handlers[i][0]);
+        }
     }
     const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
     for (let i = 0, len = handlers.length; i < len; i++) {
@@ -130,22 +141,28 @@ function verifyDuplicateParam(routes) {
     }
     return true;
 }
-class RegExpRouter extends router_1.Router {
+class RegExpRouter {
     constructor() {
-        super(...arguments);
-        this.routeData = { routes: [], methods: new Set() };
+        this.routeData = { index: 0, routes: [], methods: new Set() };
     }
     add(method, path, handler) {
         if (!this.routeData) {
             throw new Error('Can not add a route since the matcher is already built.');
         }
-        const { routes, methods } = this.routeData;
+        this.routeData.index++;
+        const { index, routes, methods } = this.routeData;
         if (path === '/*') {
             path = '*';
         }
+        const hint = initHint(path);
+        const handlerWithSortIndex = {
+            index,
+            handler,
+            componentsLength: hint.components.length,
+        };
         for (let i = 0, len = routes.length; i < len; i++) {
             if (routes[i].method === method && routes[i].path === path) {
-                routes[i].handlers.push(handler);
+                routes[i].handlers.push(handlerWithSortIndex);
                 return;
             }
         }
@@ -153,8 +170,8 @@ class RegExpRouter extends router_1.Router {
         routes.push({
             method,
             path,
-            handlers: [handler],
-            hint: initHint(path),
+            hint,
+            handlers: [handlerWithSortIndex],
             middleware: [],
             paramAliasMap: {},
         });
@@ -163,7 +180,8 @@ class RegExpRouter extends router_1.Router {
         const [primaryMatchers, secondaryMatchers, hasAmbiguous] = this.buildAllMatchers();
         this.match = hasAmbiguous
             ? (method, path) => {
-                const matcher = primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL];
+                const matcher = (primaryMatchers[method] ||
+                    primaryMatchers[router_1.METHOD_NAME_ALL]);
                 let match = path.match(matcher[0]);
                 if (!match) {
                     // do not support secondary matchers here.
@@ -193,10 +211,10 @@ class RegExpRouter extends router_1.Router {
                     regExpSrc = regExpSrc.replace(new RegExp(`((?:(?:\\(\\?:|.)*?\\([^)]*\\)){${index - 1}}.*?)\\(\\)`), '$1(^)');
                     match = path.match(new RegExp(regExpSrc));
                 }
-                return new router_1.Result([...handlers.values()], params);
+                return { handlers: getSortedHandlers(handlers.values()), params };
             }
             : (method, path) => {
-                let matcher = primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL];
+                let matcher = (primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL]);
                 let match = path.match(matcher[0]);
                 if (!match) {
                     const matchers = secondaryMatchers[method] || secondaryMatchers[router_1.METHOD_NAME_ALL];
@@ -209,15 +227,15 @@ class RegExpRouter extends router_1.Router {
                     }
                 }
                 const index = match.indexOf('', 1);
-                const [handler, paramMap] = matcher[1][index];
+                const [handlers, paramMap] = matcher[1][index];
                 if (!paramMap) {
-                    return new router_1.Result(handler, emptyParam);
+                    return { handlers, params: emptyParam };
                 }
                 const params = {};
                 for (let i = 0, len = paramMap.length; i < len; i++) {
                     params[paramMap[i][0]] = match[paramMap[i][1]];
                 }
-                return new router_1.Result(handler, params);
+                return { handlers, params };
             };
         return this.match(method, path);
     }
@@ -296,7 +314,17 @@ class RegExpRouter extends router_1.Router {
                             routes[j].path = components.join('');
                         }
                     }
-                    routes[j].middleware.push(...routes[i].handlers);
+                    if (routes[j].hint.components.length < routes[i].hint.components.length) {
+                        const componentsLength = routes[j].hint.components.length;
+                        routes[j].middleware.push(...routes[i].handlers.map((h) => ({
+                            componentsLength,
+                            index: h.index,
+                            handler: h.handler,
+                        })));
+                    }
+                    else {
+                        routes[j].middleware.push(...routes[i].handlers);
+                    }
                     routes[i].hint.maybeHandler = false;
                 }
                 else if (compareResult === 2) {

package/dist/router/trie-router/index.js

@@ -1 +1,5 @@
-export { TrieRouter } from './router';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrieRouter = void 0;
+var router_1 = require("./router");
+Object.defineProperty(exports, "TrieRouter", { enumerable: true, get: function () { return router_1.TrieRouter; } });

package/dist/router/trie-router/node.d.ts

@@ -1,13 +1,20 @@
-import { Result } from '../../router';
+import type { Result } from '../../router';
 import type { Pattern } from '../../utils/url';
+declare type HandlerSet<T> = {
+    handler: T;
+    score: number;
+    name: string;
+};
 export declare class Node<T> {
-    methods: Record<string, T>[];
-    handlers: T[];
+    methods: Record<string, HandlerSet<T>>[];
     children: Record<string, Node<T>>;
     patterns: Pattern[];
+    order: number;
+    name: string;
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
-    private getHandlers;
+    private getHandlerSets;
     private next;
     search(method: string, path: string): Result<T>;
 }
+export {};

package/dist/router/trie-router/node.js

@@ -1,5 +1,8 @@
-import { Result, METHOD_NAME_ALL } from '../../router';
-import { splitPath, getPattern } from '../../utils/url';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const router_1 = require("../../router");
+const url_1 = require("../../utils/url");
 function findParam(node, name) {
     for (let i = 0, len = node.patterns.length; i < len; i++) {
         if (typeof node.patterns[i] === 'object' && node.patterns[i][1] === name) {
@@ -14,21 +17,24 @@ function findParam(node, name) {
     }
     return false;
 }
-export class Node {
+class Node {
     constructor(method, handler, children) {
+        this.order = 0;
         this.children = children || {};
         this.methods = [];
         if (method && handler) {
             const m = {};
-            m[method] = handler;
+            m[method] = { handler: handler, score: 0, name: this.name };
             this.methods = [m];
         }
         this.patterns = [];
     }
     insert(method, path, handler) {
+        this.name = `${method} ${path}`;
+        this.order = ++this.order;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let curNode = this;
-        const parts = splitPath(path);
+        const parts = (0, url_1.splitPath)(path);
         const parentPatterns = [];
         const errorMessage = (name) => {
             return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
@@ -41,7 +47,7 @@ export class Node {
                 continue;
             }
             curNode.children[p] = new Node();
-            const pattern = getPattern(p);
+            const pattern = (0, url_1.getPattern)(p);
             if (pattern) {
                 if (typeof pattern === 'object') {
                     for (let j = 0, len = parentPatterns.length; j < len; j++) {
@@ -59,32 +65,39 @@ export class Node {
             parentPatterns.push(...curNode.patterns);
             curNode = curNode.children[p];
         }
+        let score = 1;
+        if (path === '*') {
+            score = score + this.order * 0.01;
+        }
+        else {
+            score = parts.length + 1 + this.order * 0.01;
+        }
         if (!curNode.methods.length) {
             curNode.methods = [];
         }
         const m = {};
-        m[method] = handler;
+        const handlerSet = { handler: handler, name: this.name, score: score };
+        m[method] = handlerSet;
         curNode.methods.push(m);
         return curNode;
     }
-    getHandlers(node, method) {
-        const handlers = [];
+    getHandlerSets(node, method, wildcard) {
+        const handlerSets = [];
         node.methods.map((m) => {
-            let handler = m[method];
-            if (handler !== undefined) {
-                handlers.push(handler);
-                return;
-            }
-            handler = m[METHOD_NAME_ALL];
-            if (handler !== undefined) {
-                handlers.push(handler);
+            const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
+            if (handlerSet !== undefined) {
+                const hs = Object.assign({}, handlerSet);
+                if (wildcard) {
+                    hs.score = handlerSet.score - 1;
+                }
+                handlerSets.push(hs);
                 return;
             }
         });
-        return handlers;
+        return handlerSets;
     }
     next(node, part, method, isLast) {
-        const handlers = [];
+        const handlerSets = [];
         const nextNodes = [];
         const params = {};
         for (let j = 0, len = node.patterns.length; j < len; j++) {
@@ -94,7 +107,11 @@ export class Node {
             if (pattern === '*') {
                 const astNode = node.children['*'];
                 if (astNode) {
-                    handlers.push(...this.getHandlers(astNode, method));
+                    let wildcard = false;
+                    if (!Object.keys(astNode.children).length) {
+                        wildcard = true;
+                    }
+                    handlerSets.push(...this.getHandlerSets(astNode, method, wildcard));
                     nextNodes.push(astNode);
                 }
             }
@@ -106,7 +123,7 @@ export class Node {
             if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
                 if (typeof key === 'string') {
                     if (isLast === true) {
-                        handlers.push(...this.getHandlers(node.children[key], method));
+                        handlerSets.push(...this.getHandlerSets(node.children[key], method));
                     }
                     nextNodes.push(node.children[key]);
                 }
@@ -119,27 +136,27 @@ export class Node {
         if (nextNode) {
             if (isLast === true) {
                 // '/hello/*' => match '/hello'
-                if (nextNode.children['*'] !== undefined) {
-                    handlers.push(...this.getHandlers(nextNode.children['*'], method));
+                if (nextNode.children['*']) {
+                    handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
                 }
-                handlers.push(...this.getHandlers(nextNode, method));
+                handlerSets.push(...this.getHandlerSets(nextNode, method));
             }
             nextNodes.push(nextNode);
         }
         const next = {
             nodes: nextNodes,
-            handlers: handlers,
+            handlerSets: handlerSets,
             params: params,
         };
         return next;
     }
     search(method, path) {
-        const handlers = [];
+        const handlerSets = [];
         let params = {};
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const curNode = this;
         let curNodes = [curNode];
-        const parts = splitPath(path);
+        const parts = (0, url_1.splitPath)(path);
         for (let i = 0, len = parts.length; i < len; i++) {
             const p = parts[i];
             const isLast = i === len - 1;
@@ -149,14 +166,22 @@ export class Node {
                 if (res.nodes.length === 0) {
                     continue;
                 }
-                handlers.push(...res.handlers);
+                handlerSets.push(...res.handlerSets);
                 params = Object.assign(params, res.params);
                 tempNodes.push(...res.nodes);
             }
             curNodes = tempNodes;
         }
-        if (handlers.length <= 0)
+        if (handlerSets.length <= 0)
             return null;
-        return new Result(handlers, params);
+        const handlers = handlerSets
+            .sort((a, b) => {
+            return a.score - b.score;
+        })
+            .map((s) => {
+            return s.handler;
+        });
+        return { handlers, params };
     }
 }
+exports.Node = Node;

package/dist/router/trie-router/router.d.ts

@@ -1,7 +1,6 @@
-import { Router } from '../../router';
-import type { Result } from '../../router';
+import type { Result, Router } from '../../router';
 import { Node } from './node';
-export declare class TrieRouter<T> extends Router<T> {
+export declare class TrieRouter<T> implements Router<T> {
     node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;

package/dist/router/trie-router/router.js

@@ -1,9 +1,10 @@
-import { Router } from '../../router';
-import { Node } from './node';
-export class TrieRouter extends Router {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrieRouter = void 0;
+const node_1 = require("./node");
+class TrieRouter {
     constructor() {
-        super();
-        this.node = new Node();
+        this.node = new node_1.Node();
     }
     add(method, path, handler) {
         this.node.insert(method, path, handler);
@@ -12,3 +13,4 @@ export class TrieRouter extends Router {
         return this.node.search(method, path);
     }
 }
+exports.TrieRouter = TrieRouter;

package/dist/router.d.ts

@@ -1,11 +1,10 @@
 export declare const METHOD_NAME_ALL: "ALL";
 export declare const METHOD_NAME_ALL_LOWERCASE: "all";
-export declare abstract class Router<T> {
-    abstract add(method: string, path: string, handler: T): void;
-    abstract match(method: string, path: string): Result<T> | null;
+export interface Router<T> {
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
 }
-export declare class Result<T> {
+export interface Result<T> {
     handlers: T[];
     params: Record<string, string>;
-    constructor(handlers: T[], params: Record<string, string>);
 }

package/dist/router.js

@@ -1,10 +1,5 @@
-export const METHOD_NAME_ALL = 'ALL';
-export const METHOD_NAME_ALL_LOWERCASE = 'all';
-export class Router {
-}
-export class Result {
-    constructor(handlers, params) {
-        this.handlers = handlers;
-        this.params = params;
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METHOD_NAME_ALL_LOWERCASE = exports.METHOD_NAME_ALL = void 0;
+exports.METHOD_NAME_ALL = 'ALL';
+exports.METHOD_NAME_ALL_LOWERCASE = 'all';

package/dist/utils/buffer.js

@@ -1,5 +1,8 @@
-import { sha256 } from './crypto';
-export const equal = (a, b) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToString = exports.timingSafeEqual = exports.equal = void 0;
+const crypto_1 = require("./crypto");
+const equal = (a, b) => {
     if (a === b) {
         return true;
     }
@@ -16,18 +19,21 @@ export const equal = (a, b) => {
     }
     return true;
 };
-export const timingSafeEqual = async (a, b, hashFunction) => {
+exports.equal = equal;
+const timingSafeEqual = async (a, b, hashFunction) => {
     if (!hashFunction) {
-        hashFunction = sha256;
+        hashFunction = crypto_1.sha256;
     }
     const sa = await hashFunction(a);
     const sb = await hashFunction(b);
     return sa === sb && a === b;
 };
-export const bufferToString = (buffer) => {
+exports.timingSafeEqual = timingSafeEqual;
+const bufferToString = (buffer) => {
     if (buffer instanceof ArrayBuffer) {
         const enc = new TextDecoder('utf-8');
         return enc.decode(buffer);
     }
     return buffer;
 };
+exports.bufferToString = bufferToString;

package/dist/utils/cloudflare.js

@@ -1,4 +1,7 @@
-export const getContentFromKVAsset = async (path, options) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKVFilePath = exports.getContentFromKVAsset = void 0;
+const getContentFromKVAsset = async (path, options) => {
     let ASSET_MANIFEST = {};
     if (options && options.manifest) {
         if (typeof options.manifest === 'string') {
@@ -33,7 +36,8 @@ export const getContentFromKVAsset = async (path, options) => {
     }
     return content;
 };
-export const getKVFilePath = (options) => {
+exports.getContentFromKVAsset = getContentFromKVAsset;
+const getKVFilePath = (options) => {
     let filename = options.filename;
     let root = options.root || '';
     const defaultDocument = options.defaultDocument || 'index.html';
@@ -54,3 +58,4 @@ export const getKVFilePath = (options) => {
     path = path.replace(/^\.?\//, '');
     return path;
 };
+exports.getKVFilePath = getKVFilePath;

package/dist/utils/crypto.js

@@ -1,14 +1,19 @@
-export const sha256 = async (data) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHash = exports.sha1 = exports.sha256 = void 0;
+const sha256 = async (data) => {
     const algorithm = { name: 'SHA-256', alias: 'sha256' };
-    const hash = await createHash(data, algorithm);
+    const hash = await (0, exports.createHash)(data, algorithm);
     return hash;
 };
-export const sha1 = async (data) => {
+exports.sha256 = sha256;
+const sha1 = async (data) => {
     const algorithm = { name: 'SHA-1', alias: 'sha1' };
-    const hash = await createHash(data, algorithm);
+    const hash = await (0, exports.createHash)(data, algorithm);
     return hash;
 };
-export const createHash = async (data, algorithm) => {
+exports.sha1 = sha1;
+const createHash = async (data, algorithm) => {
     if (crypto && crypto.subtle) {
         const buffer = await crypto.subtle.digest({
             name: algorithm.name,
@@ -18,13 +23,5 @@ export const createHash = async (data, algorithm) => {
             .join('');
         return hash;
     }
-    try {
-        const crypto = require('crypto');
-        const hash = crypto.createHash(algorithm.alias).update(data).digest('hex');
-        return hash;
-    }
-    catch (e) {
-        console.error(`If you want to create hash ${algorithm.name}, polyfill "crypto" module.`);
-        throw e;
-    }
 };
+exports.createHash = createHash;

package/dist/utils/encode.js

@@ -1,27 +1,4 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.arrayBufferToBase64URL = exports.arrayBufferToBase64 = exports.utf8ToUint8Array = exports.decodeBase64URL = exports.encodeBase64URL = exports.decodeBase64 = exports.encodeBase64 = void 0;
 const encodeBase64 = (str) => {
@@ -35,7 +12,6 @@ const encodeBase64 = (str) => {
     }
     catch (_a) { }
     try {
-        const { Buffer } = require('buffer');
         return Buffer.from(str).toString('base64');
     }
     catch (e) {
@@ -56,7 +32,6 @@ const decodeBase64 = (str) => {
     }
     catch (_a) { }
     try {
-        const { Buffer } = require('buffer');
         return Buffer.from(str, 'base64').toString();
     }
     catch (e) {
@@ -93,7 +68,6 @@ const arrayBufferToBase64 = async (buf) => {
         return btoa(String.fromCharCode(...new Uint8Array(buf)));
     }
     try {
-        const { Buffer } = await Promise.resolve().then(() => __importStar(require('buffer')));
         return Buffer.from(String.fromCharCode(...new Uint8Array(buf))).toString('base64');
     }
     catch (e) { }

package/dist/utils/http-status.js

@@ -1,7 +1,11 @@
-export const getStatusText = (statusCode) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatusText = void 0;
+const getStatusText = (statusCode) => {
     const text = statuses[statusCode];
     return text;
 };
+exports.getStatusText = getStatusText;
 const statuses = {
     100: 'Continue',
     101: 'Switching Protocols',

package/dist/utils/mime.js

@@ -1,4 +1,7 @@
-export const getMimeType = (filename) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMimeType = void 0;
+const getMimeType = (filename) => {
     const regexp = /\.([a-zA-Z0-9]+?)$/;
     const match = filename.match(regexp);
     if (!match)
@@ -9,6 +12,7 @@ export const getMimeType = (filename) => {
     }
     return mimeType;
 };
+exports.getMimeType = getMimeType;
 const mimes = {
     aac: 'audio/aac',
     abw: 'application/x-abiword',

package/dist/utils/url.js

@@ -1,13 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePath = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
 const URL_REGEXP = /^https?:\/\/[a-zA-Z0-9\-\.:]+(\/?[^?#]*)/;
-export const splitPath = (path) => {
+const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
     if (paths[0] === '') {
         paths.shift();
     }
     return paths;
 };
+exports.splitPath = splitPath;
 const patternCache = {};
-export const getPattern = (label) => {
+const getPattern = (label) => {
     // *            => wildcard
     // :id{[0-9]+}  => ([0-9]+)
     // :id          => (.+)
@@ -29,7 +33,8 @@ export const getPattern = (label) => {
     }
     return null;
 };
-export const getPathFromURL = (url, params = { strict: true }) => {
+exports.getPattern = getPattern;
+const getPathFromURL = (url, params = { strict: true }) => {
     // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
     // default is true
     if (params.strict === false && url.endsWith('/')) {
@@ -41,14 +46,16 @@ export const getPathFromURL = (url, params = { strict: true }) => {
     }
     return '';
 };
-export const isAbsoluteURL = (url) => {
+exports.getPathFromURL = getPathFromURL;
+const isAbsoluteURL = (url) => {
     const match = url.match(URL_REGEXP);
     if (match) {
         return true;
     }
     return false;
 };
-export const mergePath = (...paths) => {
+exports.isAbsoluteURL = isAbsoluteURL;
+const mergePath = (...paths) => {
     let p = '';
     let endsWithSlash = false;
     for (let path of paths) {
@@ -75,3 +82,4 @@ export const mergePath = (...paths) => {
     }
     return p;
 };
+exports.mergePath = mergePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,7 @@
     "test": "jest",
     "lint": "eslint --ext js,ts src .eslintrc.js",
     "lint:fix": "eslint --ext js,ts src .eslintrc.js --fix",
-    "build": "rimraf dist && tsc --project tsconfig.build.json && tsc --project tsconfig.build.esm.json",
+    "build": "rimraf dist && tsc --project tsconfig.build.esm.json && tsc --project tsconfig.build.json",
     "watch": "tsc --project tsconfig.build.json -w",
     "prepublishOnly": "yarn build"
   },