breeze-client 2.1.7-mjs → 2.2.0-cjs

package/esm2015/src/core.js

@@ -0,0 +1,714 @@
+/** See if this comment will make it into .d.ts */
+import { BreezeEnum } from './enum';
+let hasOwnProperty = uncurry(Object.prototype.hasOwnProperty);
+let arraySlice = uncurry(Array.prototype.slice);
+const ɵ0 = function () {
+    try {
+        return !!(Object.getPrototypeOf && Object.defineProperty({}, 'x', {}));
+    }
+    catch (e) {
+        return false;
+    }
+};
+let isES5Supported = ɵ0();
+// iterate over object
+function objectForEach(obj, kvFn) {
+    for (let key in obj) {
+        if (hasOwnProperty(obj, key)) {
+            kvFn(key, obj[key]);
+        }
+    }
+}
+function objectMap(obj, kvFn) {
+    let results = [];
+    for (let key in obj) {
+        if (hasOwnProperty(obj, key)) {
+            let result = kvFn ? kvFn(key, obj[key]) : obj[key];
+            if (result !== undefined) {
+                results.push(result);
+            }
+        }
+    }
+    return results;
+}
+function objectFirst(obj, kvPredicate) {
+    for (let key in obj) {
+        if (hasOwnProperty(obj, key)) {
+            let value = obj[key];
+            if (kvPredicate(key, value)) {
+                return { key: key, value: value };
+            }
+        }
+    }
+    return null;
+}
+function arrayFlatMap(arr, mapFn) {
+    return Array.prototype.concat.apply([], arr.map(mapFn));
+}
+function isSettable(obj, propertyName) {
+    let pd = getPropDescriptor(obj, propertyName);
+    if (pd == null)
+        return true;
+    return !!(pd.writable || pd.set);
+}
+function getPropDescriptor(obj, propertyName) {
+    if (!isES5Supported)
+        return undefined;
+    if (obj.hasOwnProperty(propertyName)) {
+        return Object.getOwnPropertyDescriptor(obj, propertyName);
+    }
+    else {
+        let nextObj = Object.getPrototypeOf(obj);
+        if (nextObj == null)
+            return undefined;
+        return getPropDescriptor(nextObj, propertyName);
+    }
+}
+// Functional extensions
+/** can be used like: persons.filter(propEq("firstName", "John")) */
+function propEq(propertyName, value) {
+    return function (obj) {
+        return obj[propertyName] === value;
+    };
+}
+/** can be used like: persons.filter(propEq("firstName", "FirstName", "John")) */
+function propsEq(property1Name, property2Name, value) {
+    return function (obj) {
+        return obj[property1Name] === value || obj[property2Name] === value;
+    };
+}
+/** can be used like persons.map(pluck("firstName")) */
+function pluck(propertyName) {
+    return function (obj) {
+        return obj[propertyName];
+    };
+}
+// end functional extensions
+/** Return an array of property values from source */
+function getOwnPropertyValues(source) {
+    let result = [];
+    for (let name in source) {
+        if (hasOwnProperty(source, name)) {
+            result.push(source[name]);
+        }
+    }
+    return result;
+}
+/** Copy properties from source to target. Returns target. */
+function extend(target, source, propNames) {
+    if (!source)
+        return target;
+    if (propNames) {
+        propNames.forEach(function (propName) {
+            target[propName] = source[propName];
+        });
+    }
+    else {
+        for (let propName in source) {
+            if (hasOwnProperty(source, propName)) {
+                target[propName] = source[propName];
+            }
+        }
+    }
+    return target;
+}
+/** Copy properties from defaults iff undefined on target.  Returns target. */
+function updateWithDefaults(target, defaults) {
+    for (let name in defaults) {
+        if (target[name] === undefined) {
+            target[name] = defaults[name];
+        }
+    }
+    return target;
+}
+/** Set ctor.defaultInstance to an instance of ctor with properties from target.
+    We want to insure that the object returned by ctor.defaultInstance is always immutable
+    Use 'target' as the primary template for the ctor.defaultInstance;
+    Use current 'ctor.defaultInstance' as the template for any missing properties
+    creates a new instance for ctor.defaultInstance
+    returns target unchanged */
+function setAsDefault(target, ctor) {
+    ctor.defaultInstance = updateWithDefaults(new ctor(target), ctor.defaultInstance);
+    return target;
+}
+/**
+    'source' is an object that will be transformed into another
+    'template' is a map where the
+       keys: are the keys to return
+         if a key contains ','s then the key is treated as a delimited string with first of the
+         keys being the key to return and the others all valid aliases for this key
+       'values' are either
+           1) the 'default' value of the key
+           2) a function that takes in the source value and should return the value to set
+         The value from the source is then set on the target,
+         after first passing thru the fn, if provided, UNLESS:
+           1) it is the default value
+           2) it is undefined ( nulls WILL be set)
+    'target' is optional
+       - if it exists then properties of the target will be set ( overwritten if the exist)
+       - if it does not exist then a new object will be created as filled.
+    'target is returned.
+*/
+function toJson(source, template, target = {}) {
+    for (let key in template) {
+        let aliases = key.split(",");
+        let defaultValue = template[key];
+        // using some as a forEach with a 'break'
+        aliases.some(function (propName) {
+            if (!(propName in source))
+                return false;
+            let value = source[propName];
+            // there is a functional property defined with this alias ( not what we want to replace).
+            if (typeof value === 'function')
+                return false;
+            // '==' is deliberate here - idea is that null or undefined values will never get serialized
+            // if default value is set to null.
+            // tslint:disable-next-line
+            if (value == defaultValue)
+                return true;
+            if (Array.isArray(value) && value.length === 0)
+                return true;
+            if (typeof (defaultValue) === "function") {
+                value = defaultValue(value);
+            }
+            else if (typeof (value) === "object") {
+                if (value && value instanceof BreezeEnum) {
+                    value = value.name;
+                }
+            }
+            if (value === undefined)
+                return true;
+            target[aliases[0]] = value;
+            return true;
+        });
+    }
+    return target;
+}
+/** Replacer function for toJSONSafe, when serializing entities.  Excludes entityAspect and other internal properties. */
+function toJSONSafeReplacer(prop, val) {
+    if (prop === "entityAspect" || prop === "complexAspect" || prop === "entityType" || prop === "complexType"
+        || prop === "getProperty" || prop === "setProperty"
+        || prop === "constructor" || prop.charAt(0) === '_' || prop.charAt(0) === '$')
+        return;
+    return val;
+}
+/** Safely perform toJSON logic on objects with cycles. */
+function toJSONSafe(obj, replacer) {
+    if (obj !== Object(obj))
+        return obj; // primitive value
+    if (obj._$visited)
+        return undefined;
+    if (obj.toJSON) {
+        let newObj = obj.toJSON();
+        if (newObj !== Object(newObj))
+            return newObj; // primitive value
+        if (newObj !== obj)
+            return toJSONSafe(newObj, replacer);
+        // toJSON returned the object unchanged.
+        obj = newObj;
+    }
+    obj._$visited = true;
+    let result;
+    if (obj instanceof Array) {
+        result = obj.map(function (o) {
+            return toJSONSafe(o, replacer);
+        });
+    }
+    else if (typeof (obj) === "function") {
+        result = undefined;
+    }
+    else {
+        result = {};
+        for (let prop in obj) {
+            if (prop === "_$visited")
+                continue;
+            let val = obj[prop];
+            if (replacer) {
+                val = replacer(prop, val);
+                if (val === undefined)
+                    continue;
+            }
+            val = toJSONSafe(val, replacer);
+            if (val === undefined)
+                continue;
+            result[prop] = val;
+        }
+    }
+    delete obj._$visited;
+    return result;
+}
+/** Resolves the values of a list of properties by checking each property in multiple sources until a value is found. */
+function resolveProperties(sources, propertyNames) {
+    let r = {};
+    let length = sources.length;
+    propertyNames.forEach(function (pn) {
+        for (let i = 0; i < length; i++) {
+            let src = sources[i];
+            if (src) {
+                let val = src[pn];
+                if (val !== undefined) {
+                    r[pn] = val;
+                    break;
+                }
+            }
+        }
+    });
+    return r;
+}
+// array functions
+function toArray(item) {
+    if (item == null) {
+        return [];
+    }
+    else if (Array.isArray(item)) {
+        return item;
+    }
+    else {
+        return [item];
+    }
+}
+/** a version of Array.map that doesn't require an array, i.e. works on arrays and scalars. */
+// function map<T, U>(items: T | T[], fn: (v: T, ix?: number) => U, includeNull?: boolean): U | U[] {
+function map(items, fn, includeNull) {
+    // whether to return nulls in array of results; default = true;
+    includeNull = includeNull == null ? true : includeNull;
+    if (items == null)
+        return items;
+    // let result: U[];
+    if (Array.isArray(items)) {
+        let result = [];
+        items.forEach(function (v, ix) {
+            let r = fn(v, ix);
+            if (r != null || includeNull) {
+                result[ix] = r;
+            }
+        });
+        return result;
+    }
+    else {
+        let result = fn(items);
+        return result;
+    }
+}
+function arrayFirst(array, predicate) {
+    for (let i = 0, j = array.length; i < j; i++) {
+        if (predicate(array[i])) {
+            return array[i];
+        }
+    }
+    return null;
+}
+function arrayIndexOf(array, predicate) {
+    for (let i = 0, j = array.length; i < j; i++) {
+        if (predicate(array[i]))
+            return i;
+    }
+    return -1;
+}
+/** Add item if not already in array */
+function arrayAddItemUnique(array, item) {
+    let ix = array.indexOf(item);
+    if (ix === -1)
+        array.push(item);
+}
+/** Remove items from the array
+ * @param array
+ * @param predicateOrItem - item to remove, or function to determine matching item
+ * @param shouldRemoveMultiple - true to keep removing after first match, false otherwise
+ */
+function arrayRemoveItem(array, predicateOrItem, shouldRemoveMultiple) {
+    let predicate = (isFunction(predicateOrItem) ? predicateOrItem : undefined);
+    let lastIx = array.length - 1;
+    let removed = false;
+    for (let i = lastIx; i >= 0; i--) {
+        if (predicate ? predicate(array[i]) : (array[i] === predicateOrItem)) {
+            array.splice(i, 1);
+            removed = true;
+            if (!shouldRemoveMultiple) {
+                return true;
+            }
+        }
+    }
+    return removed;
+}
+/** Combine array elements using the callback.  Returns array with length == min(a1.length, a2.length) */
+function arrayZip(a1, a2, callback) {
+    let result = [];
+    let n = Math.min(a1.length, a2.length);
+    for (let i = 0; i < n; ++i) {
+        result.push(callback(a1[i], a2[i]));
+    }
+    return result;
+}
+//function arrayDistinct(array) {
+//    array = array || [];
+//    let result = [];
+//    for (let i = 0, j = array.length; i < j; i++) {
+//        if (result.indexOf(array[i]) < 0)
+//            result.push(array[i]);
+//    }
+//    return result;
+//}
+// Not yet needed
+//// much faster but only works on array items with a toString method that
+//// returns distinct string for distinct objects.  So this is safe for arrays with primitive
+//// types but not for arrays with object types, unless toString() has been implemented.
+//function arrayDistinctUnsafe(array) {
+//    let o = {}, i, l = array.length, r = [];
+//    for (i = 0; i < l; i += 1) {
+//        let v = array[i];
+//        o[v] = v;
+//    }
+//    for (i in o) r.push(o[i]);
+//    return r;
+//}
+function arrayEquals(a1, a2, equalsFn) {
+    //Check if the arrays are undefined/null
+    if (!a1 || !a2)
+        return false;
+    if (a1.length !== a2.length)
+        return false;
+    //go thru all the vars
+    for (let i = 0; i < a1.length; i++) {
+        //if the let is an array, we need to make a recursive check
+        //otherwise we'll just compare the values
+        if (Array.isArray(a1[i])) {
+            if (!arrayEquals(a1[i], a2[i]))
+                return false;
+        }
+        else {
+            if (equalsFn) {
+                if (!equalsFn(a1[i], a2[i]))
+                    return false;
+            }
+            else {
+                if (a1[i] !== a2[i])
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+// end of array functions
+/** Returns an array for a source and a prop, and creates the prop if needed. */
+function getArray(source, propName) {
+    let arr = source[propName];
+    if (!arr) {
+        arr = [];
+        source[propName] = arr;
+    }
+    return arr;
+}
+/** Calls requireLibCore on semicolon-separated libNames */
+function requireLib(libNames, errMessage) {
+    let arrNames = libNames.split(";");
+    for (let i = 0, j = arrNames.length; i < j; i++) {
+        let lib = requireLibCore(arrNames[i]);
+        if (lib)
+            return lib;
+    }
+    if (errMessage) {
+        throw new Error("Unable to initialize " + libNames + ".  " + errMessage);
+    }
+}
+/** Returns the 'libName' module if loaded or else returns undefined */
+function requireLibCore(libName) {
+    let win = window || (global ? global.window : undefined);
+    if (!win)
+        return; // Must run in a browser. Todo: add commonjs support
+    // get library from browser globals if we can
+    let lib = win[libName];
+    if (lib)
+        return lib;
+    // if require exists, maybe require can get it.
+    // This method is synchronous so it can't load modules with AMD.
+    // It can only obtain modules from require that have already been loaded.
+    // Developer should bootstrap such that the breeze module
+    // loads after all other libraries that breeze should find with this method
+    // See documentation
+    let r = win.require;
+    if (r) { // if require exists
+        if (r.defined) { // require.defined is not standard and may not exist
+            // require.defined returns true if module has been loaded
+            return r.defined(libName) ? r(libName) : undefined;
+        }
+        else {
+            // require.defined does not exist so we have to call require('libName') directly.
+            // The require('libName') overload is synchronous and does not load modules.
+            // It throws an exception if the module isn't already loaded.
+            try {
+                return r(libName);
+            }
+            catch (e) {
+                // require('libName') threw because module not loaded
+                return;
+            }
+        }
+    }
+}
+/** Execute fn while obj has tempValue for property */
+function using(obj, property, tempValue, fn) {
+    if (!obj) {
+        return fn();
+    }
+    let originalValue = obj[property];
+    if (tempValue === originalValue) {
+        return fn();
+    }
+    obj[property] = tempValue;
+    try {
+        return fn();
+    }
+    finally {
+        if (originalValue === undefined) {
+            delete obj[property];
+        }
+        else {
+            obj[property] = originalValue;
+        }
+    }
+}
+/** Call state = startFn(), call fn(), call endFn(state) */
+function wrapExecution(startFn, endFn, fn) {
+    let state;
+    try {
+        state = startFn();
+        return fn();
+    }
+    catch (e) {
+        if (typeof (state) === 'object') {
+            state.error = e;
+        }
+        throw e;
+    }
+    finally {
+        endFn(state);
+    }
+}
+/** Remember & return the value of fn() when it was called with its current args */
+function memoize(fn) {
+    return function () {
+        let args = arraySlice(arguments), hash = "", i = args.length, currentArg = null;
+        while (i--) {
+            currentArg = args[i];
+            hash += (currentArg === Object(currentArg)) ? JSON.stringify(currentArg) : currentArg;
+            fn.memoize || (fn.memoize = {});
+        }
+        return (hash in fn.memoize) ?
+            fn.memoize[hash] :
+            fn.memoize[hash] = fn.apply(this, args);
+    };
+}
+const uuidrex = /[xy]/g;
+function getUuid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(uuidrex, function (c) {
+        // tslint:disable-next-line
+        let r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+const durationrex = /^P((\d+Y)?(\d+M)?(\d+D)?)?(T(\d+H)?(\d+M)?(\d+S)?)?$/;
+const lettersrex = /[A-Za-z]+/g;
+function durationToSeconds(duration) {
+    // basic algorithm from https://github.com/nezasa/iso8601-js-period
+    if (typeof duration !== "string")
+        throw new Error("Invalid ISO8601 duration '" + duration + "'");
+    // regex splits as follows - grp0, grp1, y, m, d, grp2, h, m, s
+    //                           0     1     2  3  4  5     6  7  8
+    let struct = durationrex.exec(duration);
+    if (!struct)
+        throw new Error("Invalid ISO8601 duration '" + duration + "'");
+    let ymdhmsIndexes = [2, 3, 4, 6, 7, 8]; // -> grp1,y,m,d,grp2,h,m,s
+    let factors = [31104000,
+        2592000,
+        86400,
+        3600,
+        60,
+        1]; // second (1)
+    let seconds = 0;
+    for (let i = 0; i < 6; i++) {
+        let digit = struct[ymdhmsIndexes[i]];
+        // remove letters, replace by 0 if not defined
+        digit = (digit ? +digit.replace(lettersrex, '') : 0);
+        seconds += digit * factors[i];
+    }
+    return seconds;
+}
+// is functions
+function noop() {
+    // does nothing
+}
+function identity(x) {
+    return x;
+}
+function classof(o) {
+    if (o === null) {
+        return "null";
+    }
+    if (o === undefined) {
+        return "undefined";
+    }
+    return Object.prototype.toString.call(o).slice(8, -1).toLowerCase();
+}
+function isDate(o) {
+    return classof(o) === "date" && !isNaN(o.getTime());
+}
+const isdaterex = /^((\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)))$/;
+function isDateString(s) {
+    // let rx = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/;
+    return (typeof s === "string") && isdaterex.test(s);
+}
+function isFunction(o) {
+    return classof(o) === "function";
+}
+// function isString(o: any) {
+//     return (typeof o === "string");
+// }
+// function isObject(o: any) {
+//     return (typeof o === "object");
+// }
+const isguidrex = /^[a-fA-F\d]{8}-(?:[a-fA-F\d]{4}-){3}[a-fA-F\d]{12}$/;
+function isGuid(value) {
+    return (typeof value === "string") && isguidrex.test(value);
+}
+const isdurationrex = /^(-|)?P[T]?[\d\.,\-]+[YMDTHS]/;
+function isDuration(value) {
+    return (typeof value === "string") && isdurationrex.test(value);
+}
+function isEmpty(obj) {
+    if (obj === null || obj === undefined) {
+        return true;
+    }
+    for (let key in obj) {
+        if (hasOwnProperty(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isNumeric(n) {
+    return !isNaN(parseFloat(n)) && isFinite(n);
+}
+// end of is Functions
+// string functions
+function stringStartsWith(str, prefix) {
+    // returns true for empty string or null prefix
+    if ((!str))
+        return false;
+    if (prefix === "" || prefix == null)
+        return true;
+    return str.indexOf(prefix, 0) === 0;
+}
+function stringEndsWith(str, suffix) {
+    // returns true for empty string or null suffix
+    if ((!str))
+        return false;
+    if (suffix === "" || suffix == null)
+        return true;
+    return str.indexOf(suffix, str.length - suffix.length) !== -1;
+}
+// Based on fragment from Dean Edwards' Base 2 library
+/** format("a %1 and a %2", "cat", "dog") -> "a cat and a dog" */
+function formatString(str, ...params) {
+    let args = arguments;
+    let pattern = RegExp("%([1-" + (arguments.length - 1) + "])", "g");
+    return str.replace(pattern, function (match, index) {
+        return args[index];
+    });
+}
+// See http://stackoverflow.com/questions/7225407/convert-camelcasetext-to-camel-case-text
+/** Change text to title case with spaces, e.g. 'myPropertyName12' to 'My Property Name 12' */
+const camelEdges = /([A-Z](?=[A-Z][a-z])|[^A-Z](?=[A-Z])|[a-zA-Z](?=[^a-zA-Z]))/g;
+function titleCaseSpace(text) {
+    text = text.replace(camelEdges, '$1 ');
+    text = text.charAt(0).toUpperCase() + text.slice(1);
+    return text;
+}
+// end of string functions
+// See Mark Miller’s explanation of what this does.
+// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
+function uncurry(f) {
+    let call = Function.call;
+    return function () {
+        return call.apply(f, arguments);
+    };
+}
+// shims
+if (!Object.create) {
+    Object.create = function (parent) {
+        let F = function () {
+        };
+        F.prototype = parent;
+        return new F();
+    };
+}
+// strings for error messages
+const strings = {
+    "TO_TYPE": "Add 'EntityQuery.toType()' to your query, or call 'MetadataStore.setEntityTypeForResourceName()' to register an EntityType for this resourceName."
+};
+// // not all methods above are exported
+export const core = {
+    isES5Supported: isES5Supported,
+    hasOwnProperty: hasOwnProperty,
+    getOwnPropertyValues: getOwnPropertyValues,
+    getPropertyDescriptor: getPropDescriptor,
+    objectForEach: objectForEach,
+    objectFirst: objectFirst,
+    objectMap: objectMap,
+    extend: extend,
+    propEq: propEq,
+    propsEq: propsEq,
+    pluck: pluck,
+    map: map,
+    resolveProperties: resolveProperties,
+    setAsDefault: setAsDefault,
+    updateWithDefaults: updateWithDefaults,
+    getArray: getArray,
+    toArray: toArray,
+    arrayEquals: arrayEquals,
+    arraySlice: arraySlice,
+    arrayFirst: arrayFirst,
+    arrayIndexOf: arrayIndexOf,
+    arrayRemoveItem: arrayRemoveItem,
+    arrayZip: arrayZip,
+    arrayAddItemUnique: arrayAddItemUnique,
+    arrayFlatMap: arrayFlatMap,
+    requireLib: requireLib,
+    using: using,
+    wrapExecution: wrapExecution,
+    memoize: memoize,
+    getUuid: getUuid,
+    durationToSeconds: durationToSeconds,
+    isSettable: isSettable,
+    isDate: isDate,
+    isDateString: isDateString,
+    isGuid: isGuid,
+    isDuration: isDuration,
+    isFunction: isFunction,
+    isEmpty: isEmpty,
+    isNumeric: isNumeric,
+    identity: identity,
+    noop: noop,
+    stringStartsWith: stringStartsWith,
+    stringEndsWith: stringEndsWith,
+    formatString: formatString,
+    titleCase: titleCaseSpace,
+    toJson: toJson,
+    toJSONSafe: toJSONSafe,
+    toJSONSafeReplacer: toJSONSafeReplacer,
+    strings: strings
+};
+export { ɵ0 };
+// Unused
+/*
+// returns true for booleans, numbers, strings and dates
+// false for null, and non-date objects, functions, and arrays
+function isPrimitive(obj: any) {
+    if (obj == null) return false;
+    // true for numbers, strings, booleans and null, false for objects
+    if (obj != Object(obj)) return true;
+    return isDate(obj);
+}
+
+*/ 
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.js","sourceRoot":"ng://breeze-client/","sources":["src/core.ts"],"names":[],"mappings":"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","sourcesContent":["/** See if this comment will make it into .d.ts */\r\nimport { BreezeEnum } from './enum';\r\ndeclare var global: any;\r\ndeclare var window: any;\r\n\r\nexport interface ErrorCallback {\r\n    (error: Error): void;\r\n}\r\n\r\nexport interface Callback {\r\n    (data: any): void;\r\n}\r\n\r\n// type Predicate = (i: any) => boolean;\r\ntype Predicate<T> = (i: T) => boolean;\r\n\r\nlet hasOwnProperty: (obj: Object, key: string) => boolean = uncurry(Object.prototype.hasOwnProperty);\r\nlet arraySlice: (ar: any[], start?: number, end?: number) => any[] = uncurry(Array.prototype.slice);\r\nlet isES5Supported: boolean = function () {\r\n    try {\r\n        return !!(Object.getPrototypeOf && Object.defineProperty({}, 'x', {}));\r\n    } catch (e) {\r\n        return false;\r\n    }\r\n} ();\r\n\r\n// iterate over object\r\nfunction objectForEach(obj: Object, kvFn: (key: string, val: any) => any) {\r\n    for (let key in obj) {\r\n        if (hasOwnProperty(obj, key)) {\r\n            kvFn(key, obj[key]);\r\n        }\r\n    }\r\n}\r\n\r\nfunction objectMap(obj: Object, kvFn?: (key: string, val: any) => any): any[] {\r\n    let results: any[] = [];\r\n    for (let key in obj) {\r\n        if (hasOwnProperty(obj, key)) {\r\n            let result = kvFn ? kvFn(key, obj[key]) : obj[key];\r\n            if (result !== undefined) {\r\n                results.push(result);\r\n            }\r\n        }\r\n    }\r\n    return results;\r\n}\r\n\r\nfunction objectFirst(obj: Object, kvPredicate: (key: string, val: any) => boolean): { key: string, value: any } | null {\r\n    for (let key in obj) {\r\n        if (hasOwnProperty(obj, key)) {\r\n            let value = obj[key];\r\n            if (kvPredicate(key, value)) {\r\n                return { key: key, value: value };\r\n            }\r\n        }\r\n    }\r\n    return null;\r\n}\r\n\r\nfunction arrayFlatMap<T, U>(arr: T[], mapFn: (arg: T) => U[]) {\r\n    return Array.prototype.concat.apply([], arr.map(mapFn)) as U[];\r\n}\r\n\r\nfunction isSettable(obj: Object, propertyName: string): boolean {\r\n    let pd = getPropDescriptor(obj, propertyName);\r\n    if (pd == null) return true;\r\n    return !!(pd.writable || pd.set);\r\n}\r\n\r\nfunction getPropDescriptor(obj: Object, propertyName: string): PropertyDescriptor | undefined {\r\n    if (!isES5Supported) return undefined;\r\n\r\n    if (obj.hasOwnProperty(propertyName)) {\r\n        return Object.getOwnPropertyDescriptor(obj, propertyName);\r\n    } else {\r\n        let nextObj = Object.getPrototypeOf(obj);\r\n        if (nextObj == null) return undefined;\r\n        return getPropDescriptor(nextObj, propertyName);\r\n    }\r\n}\r\n\r\n// Functional extensions\r\n\r\n/** can be used like: persons.filter(propEq(\"firstName\", \"John\")) */\r\nfunction propEq(propertyName: string, value: any): (obj: Object) => boolean {\r\n    return function (obj: any) {\r\n        return obj[propertyName] === value;\r\n    };\r\n}\r\n\r\n/** can be used like: persons.filter(propEq(\"firstName\", \"FirstName\", \"John\")) */\r\nfunction propsEq(property1Name: string, property2Name: string, value: any): (obj: Object) => boolean {\r\n    return function (obj: any) {\r\n        return obj[property1Name] === value || obj[property2Name] === value;\r\n    };\r\n}\r\n\r\n/** can be used like persons.map(pluck(\"firstName\")) */\r\nfunction pluck(propertyName: any): (obj: Object) => any {\r\n    return function (obj: any) {\r\n        return obj[propertyName];\r\n    };\r\n}\r\n\r\n// end functional extensions\r\n\r\n/** Return an array of property values from source */\r\nfunction getOwnPropertyValues(source: Object): any[] {\r\n    let result: any[] = [];\r\n    for (let name in source) {\r\n        if (hasOwnProperty(source, name)) {\r\n            result.push(source[name]);\r\n        }\r\n    }\r\n    return result;\r\n}\r\n\r\n/** Copy properties from source to target. Returns target. */\r\nfunction extend(target: Object, source: Object, propNames?: string[]): Object {\r\n    if (!source) return target;\r\n    if (propNames) {\r\n        propNames.forEach(function (propName) {\r\n            target[propName] = source[propName];\r\n        });\r\n    } else {\r\n        for (let propName in source) {\r\n            if (hasOwnProperty(source, propName)) {\r\n                target[propName] = source[propName];\r\n            }\r\n        }\r\n    }\r\n    return target;\r\n}\r\n\r\n/** Copy properties from defaults iff undefined on target.  Returns target. */\r\nfunction updateWithDefaults(target: Object, defaults: Object): any {\r\n    for (let name in defaults) {\r\n        if (target[name] === undefined) {\r\n            target[name] = defaults[name];\r\n        }\r\n    }\r\n    return target;\r\n}\r\n\r\n/** Set ctor.defaultInstance to an instance of ctor with properties from target.\r\n    We want to insure that the object returned by ctor.defaultInstance is always immutable\r\n    Use 'target' as the primary template for the ctor.defaultInstance;\r\n    Use current 'ctor.defaultInstance' as the template for any missing properties\r\n    creates a new instance for ctor.defaultInstance\r\n    returns target unchanged */\r\nfunction setAsDefault(target: Object, ctor: { new (...args: any[]): any, defaultInstance?: any }): any {\r\n    ctor.defaultInstance = updateWithDefaults(new ctor(target), ctor.defaultInstance);\r\n    return target;\r\n}\r\n\r\n/**\r\n    'source' is an object that will be transformed into another\r\n    'template' is a map where the\r\n       keys: are the keys to return\r\n         if a key contains ','s then the key is treated as a delimited string with first of the\r\n         keys being the key to return and the others all valid aliases for this key\r\n       'values' are either\r\n           1) the 'default' value of the key\r\n           2) a function that takes in the source value and should return the value to set\r\n         The value from the source is then set on the target,\r\n         after first passing thru the fn, if provided, UNLESS:\r\n           1) it is the default value\r\n           2) it is undefined ( nulls WILL be set)\r\n    'target' is optional\r\n       - if it exists then properties of the target will be set ( overwritten if the exist)\r\n       - if it does not exist then a new object will be created as filled.\r\n    'target is returned.\r\n*/\r\nfunction toJson(source: Object, template: Object, target: Object = {}): Object {\r\n\r\n    for (let key in template) {\r\n        let aliases = key.split(\",\");\r\n        let defaultValue = template[key];\r\n        // using some as a forEach with a 'break'\r\n        aliases.some(function (propName) {\r\n            if (!(propName in source)) return false;\r\n            let value = source[propName];\r\n            // there is a functional property defined with this alias ( not what we want to replace).\r\n            if (typeof value === 'function') return false;\r\n            // '==' is deliberate here - idea is that null or undefined values will never get serialized\r\n            // if default value is set to null.\r\n            // tslint:disable-next-line\r\n            if (value == defaultValue) return true;\r\n            if (Array.isArray(value) && value.length === 0) return true;\r\n            if (typeof (defaultValue) === \"function\") {\r\n                value = defaultValue(value);\r\n            } else if (typeof (value) === \"object\") {\r\n                if (value && value instanceof BreezeEnum) {\r\n                    value = value.name;\r\n                }\r\n            }\r\n            if (value === undefined) return true;\r\n            target[aliases[0]] = value;\r\n            return true;\r\n        });\r\n    }\r\n    return target;\r\n}\r\n\r\n/** Replacer function for toJSONSafe, when serializing entities.  Excludes entityAspect and other internal properties. */\r\nfunction toJSONSafeReplacer(prop: string, val: any) {\r\n    if (prop === \"entityAspect\" || prop === \"complexAspect\" || prop === \"entityType\" || prop === \"complexType\"\r\n        || prop === \"getProperty\" || prop === \"setProperty\"\r\n        || prop === \"constructor\" || prop.charAt(0) === '_' || prop.charAt(0) === '$') return;\r\n    return val;\r\n}\r\n\r\n/** Safely perform toJSON logic on objects with cycles. */\r\nfunction toJSONSafe(obj: any, replacer?: (prop: string, value: any) => any): any {\r\n    if (obj !== Object(obj)) return obj; // primitive value\r\n    if (obj._$visited) return undefined;\r\n    if (obj.toJSON) {\r\n        let newObj = obj.toJSON();\r\n        if (newObj !== Object(newObj)) return newObj; // primitive value\r\n        if (newObj !== obj) return toJSONSafe(newObj, replacer);\r\n        // toJSON returned the object unchanged.\r\n        obj = newObj;\r\n    }\r\n    obj._$visited = true;\r\n    let result: any;\r\n    if (obj instanceof Array) {\r\n        result = obj.map(function (o: any) {\r\n            return toJSONSafe(o, replacer);\r\n        });\r\n    } else if (typeof (obj) === \"function\") {\r\n        result = undefined;\r\n    } else {\r\n        result = {};\r\n        for (let prop in obj) {\r\n            if (prop === \"_$visited\") continue;\r\n            let val = obj[prop];\r\n            if (replacer) {\r\n                val = replacer(prop, val);\r\n                if (val === undefined) continue;\r\n            }\r\n            val = toJSONSafe(val, replacer);\r\n            if (val === undefined) continue;\r\n            result[prop] = val;\r\n        }\r\n    }\r\n    delete obj._$visited;\r\n    return result;\r\n}\r\n\r\n/** Resolves the values of a list of properties by checking each property in multiple sources until a value is found. */\r\nfunction resolveProperties(sources: Object[], propertyNames: string[]): any {\r\n    let r = {};\r\n    let length = sources.length;\r\n    propertyNames.forEach(function (pn) {\r\n        for (let i = 0; i < length; i++) {\r\n            let src = sources[i];\r\n            if (src) {\r\n                let val = src[pn];\r\n                if (val !== undefined) {\r\n                    r[pn] = val;\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    });\r\n    return r;\r\n}\r\n\r\n\r\n// array functions\r\n\r\nfunction toArray(item: any): any[] {\r\n    if (item == null) {\r\n        return [];\r\n    } else if (Array.isArray(item)) {\r\n        return item;\r\n    } else {\r\n        return [item];\r\n    }\r\n}\r\n\r\n/** a version of Array.map that doesn't require an array, i.e. works on arrays and scalars. */\r\n// function map<T, U>(items: T | T[], fn: (v: T, ix?: number) => U, includeNull?: boolean): U | U[] {\r\n function map<T>(items: T | T[], fn: (v: T, ix?: number) => any, includeNull?: boolean): any | any[] {\r\n    // whether to return nulls in array of results; default = true;\r\n    includeNull = includeNull == null ? true : includeNull;\r\n    if (items == null) return items;\r\n    // let result: U[];\r\n    if (Array.isArray(items)) {\r\n        let result: any[] = [];\r\n        items.forEach(function (v: any, ix: number) {\r\n            let r = fn(v, ix);\r\n            if (r != null || includeNull) {\r\n                result[ix] = r;\r\n            }\r\n        });\r\n        return result;\r\n    } else {\r\n        let result = fn(items);\r\n        return result;\r\n    }\r\n\r\n}\r\n\r\n/** Return first element matching predicate */\r\nfunction arrayFirst<T>(array: T[], predicate: Predicate<any>): T;\r\nfunction arrayFirst<T>(array: T[], predicate: Predicate<T>) {\r\n    for (let i = 0, j = array.length; i < j; i++) {\r\n        if (predicate(array[i])) {\r\n            return array[i];\r\n        }\r\n    }\r\n    return null;\r\n}\r\n\r\n/** Return index of first element matching predicate */\r\nfunction arrayIndexOf<T>(array: T[], predicate: Predicate<any>): number;\r\nfunction arrayIndexOf<T>(array: T[], predicate: Predicate<T>): number {\r\n    for (let i = 0, j = array.length; i < j; i++) {\r\n        if (predicate(array[i])) return i;\r\n    }\r\n    return -1;\r\n}\r\n\r\n/** Add item if not already in array */\r\nfunction arrayAddItemUnique<T>(array: T[], item: T) {\r\n    let ix = array.indexOf(item);\r\n    if (ix === -1) array.push(item);\r\n}\r\n\r\n/** Remove items from the array\r\n * @param array\r\n * @param predicateOrItem - item to remove, or function to determine matching item\r\n * @param shouldRemoveMultiple - true to keep removing after first match, false otherwise\r\n */\r\nfunction arrayRemoveItem<T>(array: T[], predicateOrItem: T | Predicate<T> , shouldRemoveMultiple?: boolean) {\r\n    let predicate = (isFunction(predicateOrItem) ? predicateOrItem : undefined) as Predicate<T>;\r\n    let lastIx = array.length - 1;\r\n    let removed = false;\r\n    for (let i = lastIx; i >= 0; i--) {\r\n        if (predicate ? predicate(array[i]) : (array[i] === predicateOrItem)) {\r\n            array.splice(i, 1);\r\n            removed = true;\r\n            if (!shouldRemoveMultiple) {\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n    return removed;\r\n}\r\n\r\n/** Combine array elements using the callback.  Returns array with length == min(a1.length, a2.length) */\r\nfunction arrayZip(a1: any[], a2: any[], callback: (x1: any, x2: any) => any): any[] {\r\n    let result: any[] = [];\r\n    let n = Math.min(a1.length, a2.length);\r\n    for (let i = 0; i < n; ++i) {\r\n        result.push(callback(a1[i], a2[i]));\r\n    }\r\n    return result;\r\n}\r\n\r\n//function arrayDistinct(array) {\r\n//    array = array || [];\r\n//    let result = [];\r\n//    for (let i = 0, j = array.length; i < j; i++) {\r\n//        if (result.indexOf(array[i]) < 0)\r\n//            result.push(array[i]);\r\n//    }\r\n//    return result;\r\n//}\r\n\r\n// Not yet needed\r\n//// much faster but only works on array items with a toString method that\r\n//// returns distinct string for distinct objects.  So this is safe for arrays with primitive\r\n//// types but not for arrays with object types, unless toString() has been implemented.\r\n//function arrayDistinctUnsafe(array) {\r\n//    let o = {}, i, l = array.length, r = [];\r\n//    for (i = 0; i < l; i += 1) {\r\n//        let v = array[i];\r\n//        o[v] = v;\r\n//    }\r\n//    for (i in o) r.push(o[i]);\r\n//    return r;\r\n//}\r\n\r\nfunction arrayEquals(a1: any[], a2: any[], equalsFn?: (x1: any, x2: any) => boolean): boolean {\r\n    //Check if the arrays are undefined/null\r\n    if (!a1 || !a2) return false;\r\n\r\n    if (a1.length !== a2.length) return false;\r\n\r\n    //go thru all the vars\r\n    for (let i = 0; i < a1.length; i++) {\r\n        //if the let is an array, we need to make a recursive check\r\n        //otherwise we'll just compare the values\r\n        if (Array.isArray(a1[i])) {\r\n            if (!arrayEquals(a1[i], a2[i])) return false;\r\n        } else {\r\n            if (equalsFn) {\r\n                if (!equalsFn(a1[i], a2[i])) return false;\r\n            } else {\r\n                if (a1[i] !== a2[i]) return false;\r\n            }\r\n        }\r\n    }\r\n    return true;\r\n}\r\n\r\n// end of array functions\r\n\r\n/** Returns an array for a source and a prop, and creates the prop if needed. */\r\nfunction getArray(source: Object, propName: string): any[] {\r\n    let arr = source[propName];\r\n    if (!arr) {\r\n        arr = [];\r\n        source[propName] = arr;\r\n    }\r\n    return arr;\r\n}\r\n\r\n/** Calls requireLibCore on semicolon-separated libNames */\r\nfunction requireLib(libNames: string, errMessage?: string) {\r\n    let arrNames = libNames.split(\";\");\r\n    for (let i = 0, j = arrNames.length; i < j; i++) {\r\n        let lib = requireLibCore(arrNames[i]);\r\n        if (lib) return lib;\r\n    }\r\n    if (errMessage) {\r\n        throw new Error(\"Unable to initialize \" + libNames + \".  \" + errMessage);\r\n    }\r\n}\r\n\r\n\r\n\r\n/** Returns the 'libName' module if loaded or else returns undefined */\r\nfunction requireLibCore(libName: string) {\r\n    let win = window || (global ? global.window : undefined);\r\n    if (!win) return; // Must run in a browser. Todo: add commonjs support\r\n\r\n    // get library from browser globals if we can\r\n    let lib = win[libName];\r\n    if (lib) return lib;\r\n\r\n    // if require exists, maybe require can get it.\r\n    // This method is synchronous so it can't load modules with AMD.\r\n    // It can only obtain modules from require that have already been loaded.\r\n    // Developer should bootstrap such that the breeze module\r\n    // loads after all other libraries that breeze should find with this method\r\n    // See documentation\r\n    let r = win.require;\r\n    if (r) { // if require exists\r\n        if (r.defined) { // require.defined is not standard and may not exist\r\n            // require.defined returns true if module has been loaded\r\n            return r.defined(libName) ? r(libName) : undefined;\r\n        } else {\r\n            // require.defined does not exist so we have to call require('libName') directly.\r\n            // The require('libName') overload is synchronous and does not load modules.\r\n            // It throws an exception if the module isn't already loaded.\r\n            try {\r\n                return r(libName);\r\n            } catch (e) {\r\n                // require('libName') threw because module not loaded\r\n                return;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/** Execute fn while obj has tempValue for property */\r\nfunction using(obj: Object, property: string, tempValue: any, fn: () => any) {\r\n    if (!obj) {\r\n        return fn();\r\n    }\r\n    let originalValue = obj[property];\r\n    if (tempValue === originalValue) {\r\n        return fn();\r\n    }\r\n    obj[property] = tempValue;\r\n    try {\r\n        return fn();\r\n    } finally {\r\n        if (originalValue === undefined) {\r\n            delete obj[property];\r\n        } else {\r\n            obj[property] = originalValue;\r\n        }\r\n    }\r\n}\r\n\r\n/** Call state = startFn(), call fn(), call endFn(state) */\r\nfunction wrapExecution(startFn: () => any, endFn: (state: any) => any, fn: () => any) {\r\n    let state: any;\r\n    try {\r\n        state = startFn();\r\n        return fn();\r\n    } catch (e) {\r\n        if (typeof (state) === 'object') {\r\n            state.error = e;\r\n        }\r\n        throw e;\r\n    } finally {\r\n        endFn(state);\r\n    }\r\n}\r\n\r\n/** Remember & return the value of fn() when it was called with its current args */\r\nfunction memoize(fn: any): any {\r\n    return function () {\r\n        let args = arraySlice(<any>arguments),\r\n            hash = \"\",\r\n            i = args.length,\r\n            currentArg: any = null;\r\n        while (i--) {\r\n            currentArg = args[i];\r\n            hash += (currentArg === Object(currentArg)) ? JSON.stringify(currentArg) : currentArg;\r\n            fn.memoize || (fn.memoize = {});\r\n        }\r\n        return (hash in fn.memoize) ?\r\n            fn.memoize[hash] :\r\n            fn.memoize[hash] = fn.apply(this, args);\r\n    };\r\n}\r\n\r\nconst uuidrex = /[xy]/g;\r\nfunction getUuid(): string {\r\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(uuidrex, function (c) {\r\n        // tslint:disable-next-line\r\n        let r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);\r\n        return v.toString(16);\r\n    });\r\n}\r\n\r\nconst durationrex = /^P((\\d+Y)?(\\d+M)?(\\d+D)?)?(T(\\d+H)?(\\d+M)?(\\d+S)?)?$/;\r\nconst lettersrex = /[A-Za-z]+/g;\r\nfunction durationToSeconds(duration: string) {\r\n    // basic algorithm from https://github.com/nezasa/iso8601-js-period\r\n    if (typeof duration !== \"string\") throw new Error(\"Invalid ISO8601 duration '\" + duration + \"'\");\r\n\r\n    // regex splits as follows - grp0, grp1, y, m, d, grp2, h, m, s\r\n    //                           0     1     2  3  4  5     6  7  8\r\n    let struct = durationrex.exec(duration);\r\n    if (!struct) throw new Error(\"Invalid ISO8601 duration '\" + duration + \"'\");\r\n\r\n    let ymdhmsIndexes = [2, 3, 4, 6, 7, 8]; // -> grp1,y,m,d,grp2,h,m,s\r\n    let factors = [31104000, // year (360*24*60*60)\r\n        2592000,             // month (30*24*60*60)\r\n        86400,               // day (24*60*60)\r\n        3600,                // hour (60*60)\r\n        60,                  // minute (60)\r\n        1];                  // second (1)\r\n\r\n    let seconds = 0;\r\n    for (let i = 0; i < 6; i++) {\r\n        let digit = struct[ymdhmsIndexes[i]];\r\n        // remove letters, replace by 0 if not defined\r\n        digit = <any>(digit ? +digit.replace(lettersrex, '') : 0);\r\n        seconds += <any>digit * factors[i];\r\n    }\r\n    return seconds;\r\n\r\n}\r\n\r\n// is functions\r\n\r\nfunction noop() {\r\n    // does nothing\r\n}\r\n\r\nfunction identity(x: any): any {\r\n    return x;\r\n}\r\n\r\nfunction classof(o: any) {\r\n    if (o === null) {\r\n        return \"null\";\r\n    }\r\n    if (o === undefined) {\r\n        return \"undefined\";\r\n    }\r\n    return Object.prototype.toString.call(o).slice(8, -1).toLowerCase();\r\n}\r\n\r\nfunction isDate(o: any) {\r\n    return classof(o) === \"date\" && !isNaN(o.getTime());\r\n}\r\n\r\nconst isdaterex = /^((\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\d\\.\\d+([+-][0-2]\\d:[0-5]\\d|Z))|(\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\d([+-][0-2]\\d:[0-5]\\d|Z))|(\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d([+-][0-2]\\d:[0-5]\\d|Z)))$/;\r\nfunction isDateString(s: string) {\r\n    // let rx = /^(\\d{4}|[+\\-]\\d{6})(?:-(\\d{2})(?:-(\\d{2}))?)?(?:T(\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d{3}))?)?(?:(Z)|([+\\-])(\\d{2})(?::(\\d{2}))?)?)?$/;\r\n    return (typeof s === \"string\") && isdaterex.test(s);\r\n}\r\n\r\nfunction isFunction(o: any) {\r\n    return classof(o) === \"function\";\r\n}\r\n\r\n// function isString(o: any) {\r\n//     return (typeof o === \"string\");\r\n// }\r\n\r\n// function isObject(o: any) {\r\n//     return (typeof o === \"object\");\r\n// }\r\n\r\nconst isguidrex = /^[a-fA-F\\d]{8}-(?:[a-fA-F\\d]{4}-){3}[a-fA-F\\d]{12}$/;\r\nfunction isGuid(value: any) {\r\n    return (typeof value === \"string\") && isguidrex.test(value);\r\n}\r\n\r\nconst isdurationrex = /^(-|)?P[T]?[\\d\\.,\\-]+[YMDTHS]/;\r\nfunction isDuration(value: any) {\r\n    return (typeof value === \"string\") && isdurationrex.test(value);\r\n}\r\n\r\nfunction isEmpty(obj: any) {\r\n    if (obj === null || obj === undefined) {\r\n        return true;\r\n    }\r\n    for (let key in obj) {\r\n        if (hasOwnProperty(obj, key)) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n\r\nfunction isNumeric(n: any) {\r\n    return !isNaN(parseFloat(n)) && isFinite(n);\r\n}\r\n\r\n\r\n\r\n// end of is Functions\r\n\r\n// string functions\r\n\r\nfunction stringStartsWith(str: string, prefix: string) {\r\n    // returns true for empty string or null prefix\r\n    if ((!str)) return false;\r\n    if (prefix === \"\" || prefix == null) return true;\r\n    return str.indexOf(prefix, 0) === 0;\r\n}\r\n\r\nfunction stringEndsWith(str: string, suffix: string) {\r\n    // returns true for empty string or null suffix\r\n    if ((!str)) return false;\r\n    if (suffix === \"\" || suffix == null) return true;\r\n    return str.indexOf(suffix, str.length - suffix.length) !== -1;\r\n}\r\n\r\n// Based on fragment from Dean Edwards' Base 2 library\r\n/** format(\"a %1 and a %2\", \"cat\", \"dog\") -> \"a cat and a dog\" */\r\nfunction formatString(str: string, ...params: any[]) {\r\n    let args = arguments;\r\n    let pattern = RegExp(\"%([1-\" + (arguments.length - 1) + \"])\", \"g\");\r\n    return str.replace(pattern, function (match, index) {\r\n        return args[index];\r\n    });\r\n}\r\n\r\n// See http://stackoverflow.com/questions/7225407/convert-camelcasetext-to-camel-case-text\r\n/** Change text to title case with spaces, e.g. 'myPropertyName12' to 'My Property Name 12' */\r\nconst camelEdges = /([A-Z](?=[A-Z][a-z])|[^A-Z](?=[A-Z])|[a-zA-Z](?=[^a-zA-Z]))/g;\r\nfunction titleCaseSpace(text: string) {\r\n    text = text.replace(camelEdges, '$1 ');\r\n    text = text.charAt(0).toUpperCase() + text.slice(1);\r\n    return text;\r\n}\r\n\r\n// end of string functions\r\n\r\n// See Mark Miller’s explanation of what this does.\r\n// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming\r\nfunction uncurry(f: any) {\r\n    let call = Function.call;\r\n    return function () {\r\n        return call.apply(f, arguments);\r\n    };\r\n}\r\n\r\n// shims\r\n\r\nif (!Object.create) {\r\n    Object.create = function (parent: any) {\r\n        let F = <any>function () {\r\n        };\r\n        F.prototype = parent;\r\n        return new F();\r\n    };\r\n}\r\n\r\n// strings for error messages\r\n\r\nconst strings = {\r\n    \"TO_TYPE\": \"Add 'EntityQuery.toType()' to your query, or call 'MetadataStore.setEntityTypeForResourceName()' to register an EntityType for this resourceName.\"\r\n}\r\n\r\n// // not all methods above are exported\r\nexport const core = {\r\n    isES5Supported: isES5Supported,\r\n    hasOwnProperty: hasOwnProperty,\r\n    getOwnPropertyValues: getOwnPropertyValues,\r\n    getPropertyDescriptor: getPropDescriptor,\r\n    objectForEach: objectForEach,\r\n    objectFirst: objectFirst,\r\n    objectMap: objectMap, // TODO: replace this with something strongly typed.\r\n    extend: extend,\r\n    propEq: propEq,\r\n    propsEq: propsEq,\r\n    pluck: pluck,\r\n    map: map,\r\n    resolveProperties: resolveProperties,\r\n    setAsDefault: setAsDefault,\r\n    updateWithDefaults: updateWithDefaults,\r\n    getArray: getArray,\r\n    toArray: toArray,\r\n    arrayEquals: arrayEquals,\r\n    arraySlice: arraySlice,\r\n    arrayFirst: arrayFirst,\r\n    arrayIndexOf: arrayIndexOf,\r\n    arrayRemoveItem: arrayRemoveItem,\r\n    arrayZip: arrayZip,\r\n    arrayAddItemUnique: arrayAddItemUnique,\r\n    arrayFlatMap: arrayFlatMap,\r\n\r\n    requireLib: requireLib,\r\n    using: using,\r\n    wrapExecution: wrapExecution,\r\n\r\n    memoize: memoize,\r\n    getUuid: getUuid,\r\n    durationToSeconds: durationToSeconds,\r\n\r\n    isSettable: isSettable,\r\n\r\n    isDate: isDate,\r\n    isDateString: isDateString,\r\n    isGuid: isGuid,\r\n    isDuration: isDuration,\r\n    isFunction: isFunction,\r\n    isEmpty: isEmpty,\r\n    isNumeric: isNumeric,\r\n\r\n    identity: identity,\r\n    noop: noop,\r\n\r\n    stringStartsWith: stringStartsWith,\r\n    stringEndsWith: stringEndsWith,\r\n    formatString: formatString,\r\n    titleCase: titleCaseSpace,\r\n\r\n    toJson: toJson,\r\n    toJSONSafe: toJSONSafe,\r\n    toJSONSafeReplacer: toJSONSafeReplacer,\r\n\r\n    strings: strings\r\n};\r\n\r\nexport interface ErrorCallback {\r\n    (error: any): void;\r\n}\r\n\r\n\r\n// Unused\r\n/*\r\n// returns true for booleans, numbers, strings and dates\r\n// false for null, and non-date objects, functions, and arrays\r\nfunction isPrimitive(obj: any) {\r\n    if (obj == null) return false;\r\n    // true for numbers, strings, booleans and null, false for objects\r\n    if (obj != Object(obj)) return true;\r\n    return isDate(obj);\r\n}\r\n\r\n*/"]}