@chevrotain/utils 9.0.0

package/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/lib/src/api.d.ts

@@ -0,0 +1,74 @@
+export declare function isEmpty(arr: any[]): boolean;
+export declare function keys(obj: any): string[];
+export declare function values(obj: any): any[];
+export declare function mapValues<I, O>(obj: Object, callback: (value: I, key?: string) => O): O[];
+export declare function map<I, O>(arr: I[], callback: (I: any, idx?: number) => O): O[];
+export declare function flatten<T>(arr: any[]): T[];
+export declare function first<T>(arr: T[]): T;
+export declare function last<T>(arr: T[]): T;
+export declare function forEach(collection: any, iteratorCallback: Function): void;
+export declare function isString(item: any): boolean;
+export declare function isUndefined(item: any): boolean;
+export declare function isFunction(item: any): boolean;
+export declare function drop<T>(arr: T[], howMuch?: number): T[];
+export declare function dropRight<T>(arr: T[], howMuch?: number): T[];
+export declare function filter<T>(arr: T[], predicate: (T: any) => boolean): T[];
+export declare function reject<T>(arr: T[], predicate: (T: any) => boolean): T[];
+export declare function pick(obj: Object, predicate: (item: any) => boolean): {};
+export declare function has(obj: any, prop: string): boolean;
+export declare function contains<T>(arr: T[], item: any): boolean;
+/**
+ * shallow clone
+ */
+export declare function cloneArr<T>(arr: T[]): T[];
+/**
+ * shallow clone
+ */
+export declare function cloneObj(obj: Object): any;
+export declare function find<T>(arr: T[], predicate: (item: T) => boolean): T;
+export declare function findAll<T>(arr: T[], predicate: (item: T) => boolean): T[];
+export declare function reduce<T, A>(arrOrObj: Array<T> | Object, iterator: (result: A, item: any, idx?: any) => A, initial: A): A;
+export declare function compact<T>(arr: T[]): T[];
+export declare function uniq<T>(arr: T[], identity?: (item: T) => any): T[];
+export declare function partial(func: Function, ...restArgs: any[]): Function;
+export declare function isArray(obj: any): obj is any[];
+export declare function isRegExp(obj: any): obj is RegExp;
+export declare function isObject(obj: any): obj is Object;
+export declare function every<T>(arr: T[], predicate: (item: T, idx?: any) => boolean): boolean;
+export declare function difference<T>(arr: T[], values: T[]): T[];
+export declare function some<T>(arr: T[], predicate: (item: T) => boolean): boolean;
+export declare function indexOf<T>(arr: T[], value: T): number;
+export declare function sortBy<T>(arr: T[], orderFunc: (item: T) => number): T[];
+export declare function zipObject(keys: any[], values: any[]): Object;
+/**
+ * mutates! (and returns) target
+ */
+export declare function assign(target: Object, ...sources: Object[]): Object;
+/**
+ * mutates! (and returns) target
+ */
+export declare function assignNoOverwrite(target: Object, ...sources: Object[]): Object;
+export declare function defaults(...sources: any[]): any;
+export declare function groupBy<T>(arr: T[], groupKeyFunc: (item: T) => string): {
+    [groupKey: string]: T[];
+};
+/**
+ * Merge obj2 into obj1.
+ * Will overwrite existing properties with the same name
+ */
+export declare function merge(obj1: Object, obj2: Object): any;
+export declare function NOOP(): void;
+export declare function IDENTITY(item: any): any;
+/**
+ * Will return a new packed array with same values.
+ */
+export declare function packArray<T>(holeyArr: T[]): T[];
+export declare function PRINT_ERROR(msg: any): void;
+export declare function PRINT_WARNING(msg: any): void;
+export declare function isES2015MapSupported(): boolean;
+export declare function peek<T>(arr: T[]): T;
+export declare function timer<T>(func: () => T): {
+    time: number;
+    value: T;
+};
+export declare function toFastProperties(toBecomeFast: any): any;

package/lib/src/api.js

@@ -0,0 +1,456 @@
+"use strict";
+/*
+ Utils using lodash style API. (not necessarily 100% compliant) for functional and other utils.
+ These utils should replace usage of lodash in the production code base. not because they are any better...
+ but for the purpose of being a dependency free library.
+
+ The hotspots in the code are already written in imperative style for performance reasons.
+ so writing several dozen utils which may be slower than the original lodash, does not matter as much
+ considering they will not be invoked in hotspots...
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFastProperties = exports.timer = exports.peek = exports.isES2015MapSupported = exports.PRINT_WARNING = exports.PRINT_ERROR = exports.packArray = exports.IDENTITY = exports.NOOP = exports.merge = exports.groupBy = exports.defaults = exports.assignNoOverwrite = exports.assign = exports.zipObject = exports.sortBy = exports.indexOf = exports.some = exports.difference = exports.every = exports.isObject = exports.isRegExp = exports.isArray = exports.partial = exports.uniq = exports.compact = exports.reduce = exports.findAll = exports.find = exports.cloneObj = exports.cloneArr = exports.contains = exports.has = exports.pick = exports.reject = exports.filter = exports.dropRight = exports.drop = exports.isFunction = exports.isUndefined = exports.isString = exports.forEach = exports.last = exports.first = exports.flatten = exports.map = exports.mapValues = exports.values = exports.keys = exports.isEmpty = void 0;
+function isEmpty(arr) {
+    return arr && arr.length === 0;
+}
+exports.isEmpty = isEmpty;
+function keys(obj) {
+    if (obj === undefined || obj === null) {
+        return [];
+    }
+    return Object.keys(obj);
+}
+exports.keys = keys;
+function values(obj) {
+    var vals = [];
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        vals.push(obj[keys[i]]);
+    }
+    return vals;
+}
+exports.values = values;
+function mapValues(obj, callback) {
+    var result = [];
+    var objKeys = keys(obj);
+    for (var idx = 0; idx < objKeys.length; idx++) {
+        var currKey = objKeys[idx];
+        result.push(callback.call(null, obj[currKey], currKey));
+    }
+    return result;
+}
+exports.mapValues = mapValues;
+function map(arr, callback) {
+    var result = [];
+    for (var idx = 0; idx < arr.length; idx++) {
+        result.push(callback.call(null, arr[idx], idx));
+    }
+    return result;
+}
+exports.map = map;
+function flatten(arr) {
+    var result = [];
+    for (var idx = 0; idx < arr.length; idx++) {
+        var currItem = arr[idx];
+        if (Array.isArray(currItem)) {
+            result = result.concat(flatten(currItem));
+        }
+        else {
+            result.push(currItem);
+        }
+    }
+    return result;
+}
+exports.flatten = flatten;
+function first(arr) {
+    return isEmpty(arr) ? undefined : arr[0];
+}
+exports.first = first;
+function last(arr) {
+    var len = arr && arr.length;
+    return len ? arr[len - 1] : undefined;
+}
+exports.last = last;
+function forEach(collection, iteratorCallback) {
+    /* istanbul ignore else */
+    if (Array.isArray(collection)) {
+        for (var i = 0; i < collection.length; i++) {
+            iteratorCallback.call(null, collection[i], i);
+        }
+    }
+    else if (isObject(collection)) {
+        var colKeys = keys(collection);
+        for (var i = 0; i < colKeys.length; i++) {
+            var key = colKeys[i];
+            var value = collection[key];
+            iteratorCallback.call(null, value, key);
+        }
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+exports.forEach = forEach;
+function isString(item) {
+    return typeof item === "string";
+}
+exports.isString = isString;
+function isUndefined(item) {
+    return item === undefined;
+}
+exports.isUndefined = isUndefined;
+function isFunction(item) {
+    return item instanceof Function;
+}
+exports.isFunction = isFunction;
+function drop(arr, howMuch) {
+    if (howMuch === void 0) { howMuch = 1; }
+    return arr.slice(howMuch, arr.length);
+}
+exports.drop = drop;
+function dropRight(arr, howMuch) {
+    if (howMuch === void 0) { howMuch = 1; }
+    return arr.slice(0, arr.length - howMuch);
+}
+exports.dropRight = dropRight;
+function filter(arr, predicate) {
+    var result = [];
+    if (Array.isArray(arr)) {
+        for (var i = 0; i < arr.length; i++) {
+            var item = arr[i];
+            if (predicate.call(null, item)) {
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}
+exports.filter = filter;
+function reject(arr, predicate) {
+    return filter(arr, function (item) { return !predicate(item); });
+}
+exports.reject = reject;
+function pick(obj, predicate) {
+    var keys = Object.keys(obj);
+    var result = {};
+    for (var i = 0; i < keys.length; i++) {
+        var currKey = keys[i];
+        var currItem = obj[currKey];
+        if (predicate(currItem)) {
+            result[currKey] = currItem;
+        }
+    }
+    return result;
+}
+exports.pick = pick;
+function has(obj, prop) {
+    if (isObject(obj)) {
+        return obj.hasOwnProperty(prop);
+    }
+    return false;
+}
+exports.has = has;
+function contains(arr, item) {
+    return find(arr, function (currItem) { return currItem === item; }) !== undefined ? true : false;
+}
+exports.contains = contains;
+/**
+ * shallow clone
+ */
+function cloneArr(arr) {
+    var newArr = [];
+    for (var i = 0; i < arr.length; i++) {
+        newArr.push(arr[i]);
+    }
+    return newArr;
+}
+exports.cloneArr = cloneArr;
+/**
+ * shallow clone
+ */
+function cloneObj(obj) {
+    var clonedObj = {};
+    for (var key in obj) {
+        /* istanbul ignore else */
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clonedObj[key] = obj[key];
+        }
+    }
+    return clonedObj;
+}
+exports.cloneObj = cloneObj;
+function find(arr, predicate) {
+    for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+        if (predicate.call(null, item)) {
+            return item;
+        }
+    }
+    return undefined;
+}
+exports.find = find;
+function findAll(arr, predicate) {
+    var found = [];
+    for (var i = 0; i < arr.length; i++) {
+        var item = arr[i];
+        if (predicate.call(null, item)) {
+            found.push(item);
+        }
+    }
+    return found;
+}
+exports.findAll = findAll;
+function reduce(arrOrObj, iterator, initial) {
+    var isArr = Array.isArray(arrOrObj);
+    var vals = isArr ? arrOrObj : values(arrOrObj);
+    var objKeys = isArr ? [] : keys(arrOrObj);
+    var accumulator = initial;
+    for (var i = 0; i < vals.length; i++) {
+        accumulator = iterator.call(null, accumulator, vals[i], isArr ? i : objKeys[i]);
+    }
+    return accumulator;
+}
+exports.reduce = reduce;
+function compact(arr) {
+    return reject(arr, function (item) { return item === null || item === undefined; });
+}
+exports.compact = compact;
+function uniq(arr, identity) {
+    if (identity === void 0) { identity = function (item) { return item; }; }
+    var identities = [];
+    return reduce(arr, function (result, currItem) {
+        var currIdentity = identity(currItem);
+        if (contains(identities, currIdentity)) {
+            return result;
+        }
+        else {
+            identities.push(currIdentity);
+            return result.concat(currItem);
+        }
+    }, []);
+}
+exports.uniq = uniq;
+function partial(func) {
+    var restArgs = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        restArgs[_i - 1] = arguments[_i];
+    }
+    var firstArg = [null];
+    var allArgs = firstArg.concat(restArgs);
+    return Function.bind.apply(func, allArgs);
+}
+exports.partial = partial;
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+exports.isArray = isArray;
+function isRegExp(obj) {
+    return obj instanceof RegExp;
+}
+exports.isRegExp = isRegExp;
+function isObject(obj) {
+    return obj instanceof Object;
+}
+exports.isObject = isObject;
+function every(arr, predicate) {
+    for (var i = 0; i < arr.length; i++) {
+        if (!predicate(arr[i], i)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.every = every;
+function difference(arr, values) {
+    return reject(arr, function (item) { return contains(values, item); });
+}
+exports.difference = difference;
+function some(arr, predicate) {
+    for (var i = 0; i < arr.length; i++) {
+        if (predicate(arr[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.some = some;
+function indexOf(arr, value) {
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i] === value) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.indexOf = indexOf;
+function sortBy(arr, orderFunc) {
+    var result = cloneArr(arr);
+    result.sort(function (a, b) { return orderFunc(a) - orderFunc(b); });
+    return result;
+}
+exports.sortBy = sortBy;
+function zipObject(keys, values) {
+    if (keys.length !== values.length) {
+        throw Error("can't zipObject with different number of keys and values!");
+    }
+    var result = {};
+    for (var i = 0; i < keys.length; i++) {
+        result[keys[i]] = values[i];
+    }
+    return result;
+}
+exports.zipObject = zipObject;
+/**
+ * mutates! (and returns) target
+ */
+function assign(target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    for (var i = 0; i < sources.length; i++) {
+        var curSource = sources[i];
+        var currSourceKeys = keys(curSource);
+        for (var j = 0; j < currSourceKeys.length; j++) {
+            var currKey = currSourceKeys[j];
+            target[currKey] = curSource[currKey];
+        }
+    }
+    return target;
+}
+exports.assign = assign;
+/**
+ * mutates! (and returns) target
+ */
+function assignNoOverwrite(target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    for (var i = 0; i < sources.length; i++) {
+        var curSource = sources[i];
+        var currSourceKeys = keys(curSource);
+        for (var j = 0; j < currSourceKeys.length; j++) {
+            var currKey = currSourceKeys[j];
+            if (!has(target, currKey)) {
+                target[currKey] = curSource[currKey];
+            }
+        }
+    }
+    return target;
+}
+exports.assignNoOverwrite = assignNoOverwrite;
+function defaults() {
+    var sources = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        sources[_i] = arguments[_i];
+    }
+    return assignNoOverwrite.apply(void 0, __spreadArray([{}], sources));
+}
+exports.defaults = defaults;
+function groupBy(arr, groupKeyFunc) {
+    var result = {};
+    forEach(arr, function (item) {
+        var currGroupKey = groupKeyFunc(item);
+        var currGroupArr = result[currGroupKey];
+        if (currGroupArr) {
+            currGroupArr.push(item);
+        }
+        else {
+            result[currGroupKey] = [item];
+        }
+    });
+    return result;
+}
+exports.groupBy = groupBy;
+/**
+ * Merge obj2 into obj1.
+ * Will overwrite existing properties with the same name
+ */
+function merge(obj1, obj2) {
+    var result = cloneObj(obj1);
+    var keys2 = keys(obj2);
+    for (var i = 0; i < keys2.length; i++) {
+        var key = keys2[i];
+        var value = obj2[key];
+        result[key] = value;
+    }
+    return result;
+}
+exports.merge = merge;
+function NOOP() { }
+exports.NOOP = NOOP;
+function IDENTITY(item) {
+    return item;
+}
+exports.IDENTITY = IDENTITY;
+/**
+ * Will return a new packed array with same values.
+ */
+function packArray(holeyArr) {
+    var result = [];
+    for (var i = 0; i < holeyArr.length; i++) {
+        var orgValue = holeyArr[i];
+        result.push(orgValue !== undefined ? orgValue : undefined);
+    }
+    return result;
+}
+exports.packArray = packArray;
+function PRINT_ERROR(msg) {
+    /* istanbul ignore else - can't override global.console in node.js */
+    if (console && console.error) {
+        console.error("Error: " + msg);
+    }
+}
+exports.PRINT_ERROR = PRINT_ERROR;
+function PRINT_WARNING(msg) {
+    /* istanbul ignore else - can't override global.console in node.js*/
+    if (console && console.warn) {
+        // TODO: modify docs accordingly
+        console.warn("Warning: " + msg);
+    }
+}
+exports.PRINT_WARNING = PRINT_WARNING;
+function isES2015MapSupported() {
+    return typeof Map === "function";
+}
+exports.isES2015MapSupported = isES2015MapSupported;
+function peek(arr) {
+    return arr[arr.length - 1];
+}
+exports.peek = peek;
+/* istanbul ignore next - for performance tracing*/
+function timer(func) {
+    var start = new Date().getTime();
+    var val = func();
+    var end = new Date().getTime();
+    var total = end - start;
+    return { time: total, value: val };
+}
+exports.timer = timer;
+// based on: https://github.com/petkaantonov/bluebird/blob/b97c0d2d487e8c5076e8bd897e0dcd4622d31846/src/util.js#L201-L216
+function toFastProperties(toBecomeFast) {
+    function FakeConstructor() { }
+    // If our object is used as a constructor it would receive
+    FakeConstructor.prototype = toBecomeFast;
+    var fakeInstance = new FakeConstructor();
+    function fakeAccess() {
+        return typeof fakeInstance.bar;
+    }
+    // help V8 understand this is a "real" prototype by actually using
+    // the fake instance.
+    fakeAccess();
+    fakeAccess();
+    return toBecomeFast;
+    // Eval prevents optimization of this method (even though this is dead code)
+    /* istanbul ignore next */
+    // tslint:disable-next-line
+    eval(toBecomeFast);
+}
+exports.toFastProperties = toFastProperties;
+//# sourceMappingURL=api.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@chevrotain/utils",
+  "version": "9.0.0",
+  "description": "common utilities",
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/Chevrotain/chevrotain/issues"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Shahar Soel"
+  },
+  "typings": "api.d.ts",
+  "main": "lib/src/api.js",
+  "files": [
+    "lib/src/api.js",
+    "lib/src/api.ts",
+    "lib/src/api.d.ts",
+    "README.md",
+    "LICENSE.TXT"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Chevrotain/chevrotain.git"
+  },
+  "scripts": {
+    "---------- CI FLOWS --------": "",
+    "build": "npm-run-all clean compile",
+    "test": "npm-run-all coverage",
+    "---------- BUILD STEPS --------": "",
+    "clean": "shx rm -rf dev",
+    "compile:watch": "tsc -w",
+    "compile": "tsc",
+    "coverage": "nyc mocha"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.2.15"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "ca48f1b64ea7768c0cf0248572e5270f593b18c8"
+}