cydran
Version:
Unobtrusive Javascript presentation framework
1,277 lines (1,273 loc) • 478 kB
JavaScript
"use strict";
/*
0.2.1
---
Cydran <http://cydran.io/>
Copyright (c) 2018 The Cydran Team and other contributors <http://cydran.io/>
Released under MIT license <http://cydran.io/license>
---
Derivative work based on Lodash 4.17.15 <https://lodash.com/license>
Copyright (c) 2019 OpenJS Foundation and other contributors <https://openjsf.org/>
---
Derivative work based on Underscore.js
Copyright (c) 2012 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
---
Derivative work based on docReady <https://github.com/jfriend00/docReady/blob/master/license>
Copyright (c) 2014, John Friend <https://github.com/jfriend00/docReady/>
---
Derivative work based on Math.uuid.js <http://www.broofa.com>
Copyright (c) 2010 Robert Kieffer <https://www.broofa.com/2008/09/javascript-uuid-function/>
---
Derivative work based on UMD <https://github.com/umdjs/umd/blob/master/LICENSE.md>
Copyright (c) 2014 the UMD contributors <https://github.com/umdjs/umd/>
*/
var cydran = (function() {
var __getOwnPropNames = Object.getOwnPropertyNames;
var __commonJS = function(cb, mod) {
return function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
};
// dist/src/error/CydranError.js
var require_CydranError = __commonJS({
"dist/src/error/CydranError.js": function(exports) {
"use strict";
var __extends = exports && exports.__extends || function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2)
if (Object.prototype.hasOwnProperty.call(b2, p))
d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
Object.defineProperty(exports, "__esModule", { value: true });
var CydranError = function(_super) {
__extends(CydranError2, _super);
function CydranError2(msg) {
var _newTarget = this.constructor;
var _this = _super.call(this) || this;
_this.name = _newTarget.name;
_this.message = msg;
return _this;
}
return CydranError2;
}(Error);
exports.default = CydranError;
}
});
// dist/src/error/Errors.js
var require_Errors = __commonJS({
"dist/src/error/Errors.js": function(exports) {
"use strict";
var __extends = exports && exports.__extends || function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2)
if (Object.prototype.hasOwnProperty.call(b2, p))
d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.OutputStrategyError = exports.IllegalArgumentError = exports.UnknownInputError = exports.InvalidStateError = exports.UnknownStateError = exports.ValidationError = exports.UnknownRegionError = exports.UnknownElementError = exports.UnknownComponentError = exports.TemplateError = exports.SetComponentError = exports.SelectorError = exports.ScopeError = exports.RegistrationError = exports.RecursionError = exports.NullValueError = exports.ModuleAffinityError = exports.MalformedOnEventError = exports.LockedRegionError = exports.InvalidTypeError = exports.DigestLoopError = exports.AmbiguousMarkupError = exports.ComponentStateError = exports.CydranError = exports.BehaviorError = void 0;
var CydranError_1 = __importDefault(require_CydranError());
exports.CydranError = CydranError_1.default;
var AmbiguousMarkupError = function(_super) {
__extends(AmbiguousMarkupError2, _super);
function AmbiguousMarkupError2(msg) {
return _super.call(this, msg) || this;
}
return AmbiguousMarkupError2;
}(CydranError_1.default);
exports.AmbiguousMarkupError = AmbiguousMarkupError;
var DigestLoopError = function(_super) {
__extends(DigestLoopError2, _super);
function DigestLoopError2(msg) {
return _super.call(this, msg) || this;
}
return DigestLoopError2;
}(CydranError_1.default);
exports.DigestLoopError = DigestLoopError;
var InvalidTypeError = function(_super) {
__extends(InvalidTypeError2, _super);
function InvalidTypeError2(msg) {
return _super.call(this, msg) || this;
}
return InvalidTypeError2;
}(CydranError_1.default);
exports.InvalidTypeError = InvalidTypeError;
var LockedRegionError = function(_super) {
__extends(LockedRegionError2, _super);
function LockedRegionError2(msg) {
return _super.call(this, msg) || this;
}
return LockedRegionError2;
}(CydranError_1.default);
exports.LockedRegionError = LockedRegionError;
var MalformedOnEventError = function(_super) {
__extends(MalformedOnEventError2, _super);
function MalformedOnEventError2(msg) {
return _super.call(this, msg) || this;
}
return MalformedOnEventError2;
}(CydranError_1.default);
exports.MalformedOnEventError = MalformedOnEventError;
var ModuleAffinityError = function(_super) {
__extends(ModuleAffinityError2, _super);
function ModuleAffinityError2(msg) {
return _super.call(this, msg) || this;
}
return ModuleAffinityError2;
}(CydranError_1.default);
exports.ModuleAffinityError = ModuleAffinityError;
var NullValueError = function(_super) {
__extends(NullValueError2, _super);
function NullValueError2(msg) {
return _super.call(this, msg) || this;
}
return NullValueError2;
}(CydranError_1.default);
exports.NullValueError = NullValueError;
var RecursionError = function(_super) {
__extends(RecursionError2, _super);
function RecursionError2(msg) {
return _super.call(this, msg) || this;
}
return RecursionError2;
}(CydranError_1.default);
exports.RecursionError = RecursionError;
var RegistrationError = function(_super) {
__extends(RegistrationError2, _super);
function RegistrationError2(msg) {
return _super.call(this, msg) || this;
}
return RegistrationError2;
}(CydranError_1.default);
exports.RegistrationError = RegistrationError;
var ScopeError = function(_super) {
__extends(ScopeError2, _super);
function ScopeError2(msg) {
return _super.call(this, msg) || this;
}
return ScopeError2;
}(CydranError_1.default);
exports.ScopeError = ScopeError;
var SelectorError = function(_super) {
__extends(SelectorError2, _super);
function SelectorError2(msg) {
return _super.call(this, msg) || this;
}
return SelectorError2;
}(CydranError_1.default);
exports.SelectorError = SelectorError;
var SetComponentError = function(_super) {
__extends(SetComponentError2, _super);
function SetComponentError2(msg) {
return _super.call(this, msg) || this;
}
return SetComponentError2;
}(CydranError_1.default);
exports.SetComponentError = SetComponentError;
var TemplateError = function(_super) {
__extends(TemplateError2, _super);
function TemplateError2(msg) {
return _super.call(this, msg) || this;
}
return TemplateError2;
}(CydranError_1.default);
exports.TemplateError = TemplateError;
var UnknownComponentError = function(_super) {
__extends(UnknownComponentError2, _super);
function UnknownComponentError2(msg) {
return _super.call(this, msg) || this;
}
return UnknownComponentError2;
}(CydranError_1.default);
exports.UnknownComponentError = UnknownComponentError;
var UnknownElementError = function(_super) {
__extends(UnknownElementError2, _super);
function UnknownElementError2(msg) {
return _super.call(this, msg) || this;
}
return UnknownElementError2;
}(CydranError_1.default);
exports.UnknownElementError = UnknownElementError;
var UnknownRegionError = function(_super) {
__extends(UnknownRegionError2, _super);
function UnknownRegionError2(msg) {
return _super.call(this, msg) || this;
}
return UnknownRegionError2;
}(CydranError_1.default);
exports.UnknownRegionError = UnknownRegionError;
var ValidationError = function(_super) {
__extends(ValidationError2, _super);
function ValidationError2(msg) {
return _super.call(this, msg) || this;
}
return ValidationError2;
}(CydranError_1.default);
exports.ValidationError = ValidationError;
var UnknownStateError = function(_super) {
__extends(UnknownStateError2, _super);
function UnknownStateError2(msg) {
return _super.call(this, msg) || this;
}
return UnknownStateError2;
}(CydranError_1.default);
exports.UnknownStateError = UnknownStateError;
var InvalidStateError = function(_super) {
__extends(InvalidStateError2, _super);
function InvalidStateError2(msg) {
return _super.call(this, msg) || this;
}
return InvalidStateError2;
}(CydranError_1.default);
exports.InvalidStateError = InvalidStateError;
var UnknownInputError = function(_super) {
__extends(UnknownInputError2, _super);
function UnknownInputError2(msg) {
return _super.call(this, msg) || this;
}
return UnknownInputError2;
}(CydranError_1.default);
exports.UnknownInputError = UnknownInputError;
var ComponentStateError = function(_super) {
__extends(ComponentStateError2, _super);
function ComponentStateError2(msg) {
return _super.call(this, msg) || this;
}
return ComponentStateError2;
}(CydranError_1.default);
exports.ComponentStateError = ComponentStateError;
var BehaviorError = function(_super) {
__extends(BehaviorError2, _super);
function BehaviorError2(msg) {
return _super.call(this, msg) || this;
}
return BehaviorError2;
}(CydranError_1.default);
exports.BehaviorError = BehaviorError;
var IllegalArgumentError = function(_super) {
__extends(IllegalArgumentError2, _super);
function IllegalArgumentError2(msg) {
return _super.call(this, msg) || this;
}
return IllegalArgumentError2;
}(CydranError_1.default);
exports.IllegalArgumentError = IllegalArgumentError;
var OutputStrategyError = function(_super) {
__extends(OutputStrategyError2, _super);
function OutputStrategyError2(msg) {
return _super.call(this, msg) || this;
}
return OutputStrategyError2;
}(CydranError_1.default);
exports.OutputStrategyError = OutputStrategyError;
}
});
// dist/src/util/CloneEquals.js
var require_CloneEquals = __commonJS({
"dist/src/util/CloneEquals.js": function(exports, module) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isEqual = exports.cloneDeep = void 0;
var Errors_1 = require_Errors();
var LARGE_ARRAY_SIZE = 200;
var FUNC_ERROR_TEXT = "Expected a function";
var HASH_UNDEFINED = "__lodash_hash_undefined__";
var CLONE_DEEP_FLAG = 1;
var CLONE_FLAT_FLAG = 2;
var CLONE_SYMBOLS_FLAG = 4;
var COMPARE_PARTIAL_FLAG = 1;
var COMPARE_UNORDERED_FLAG = 2;
var MAX_SAFE_INTEGER = 9007199254740991;
var argsTag = "[object Arguments]";
var arrayTag = "[object Array]";
var asyncTag = "[object AsyncFunction]";
var boolTag = "[object Boolean]";
var dateTag = "[object Date]";
var errorTag = "[object Error]";
var funcTag = "[object Function]";
var genTag = "[object GeneratorFunction]";
var mapTag = "[object Map]";
var numberTag = "[object Number]";
var nullTag = "[object Null]";
var objectTag = "[object Object]";
var promiseTag = "[object Promise]";
var proxyTag = "[object Proxy]";
var regexpTag = "[object RegExp]";
var setTag = "[object Set]";
var stringTag = "[object String]";
var symbolTag = "[object Symbol]";
var undefinedTag = "[object Undefined]";
var weakMapTag = "[object WeakMap]";
var arrayBufferTag = "[object ArrayBuffer]";
var dataViewTag = "[object DataView]";
var float32Tag = "[object Float32Array]";
var float64Tag = "[object Float64Array]";
var int8Tag = "[object Int8Array]";
var int16Tag = "[object Int16Array]";
var int32Tag = "[object Int32Array]";
var uint8Tag = "[object Uint8Array]";
var uint8ClampedTag = "[object Uint8ClampedArray]";
var uint16Tag = "[object Uint16Array]";
var uint32Tag = "[object Uint32Array]";
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
var reFlags = /\w*$/;
var reIsHostCtor = /^\[object .+?Constructor\]$/;
var reIsUint = /^(?:0|[1-9]\d*)$/;
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
var cloneableTags = {};
cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
var freeGlobal = typeof global === "object" && global && global.Object === Object && global;
var freeSelf = typeof self === "object" && self && self["Object"] === Object && self;
var root = freeGlobal || freeSelf || Function("return this")();
var freeExports = typeof exports === "object" && exports && !exports.nodeType && exports;
var freeModule = freeExports && typeof module === "object" && module && !module["nodeType"] && module;
var moduleExports = freeModule && freeModule.exports === freeExports;
function arrayEach(array, iteratee) {
var length = array == null ? 0 : array.length;
var index = -1;
while (++index < length) {
if (iteratee(array[index], index, array) === false) {
break;
}
}
return array;
}
function arrayFilter(array, predicate) {
var length = array == null ? 0 : array.length;
var result = [];
var index = -1;
var resIndex = 0;
while (++index < length) {
var value = array[index];
if (predicate(value, index, array)) {
result[resIndex++] = value;
}
}
return result;
}
function arrayPush(array, values) {
var length = values.length;
var offset = array.length;
var index = -1;
while (++index < length) {
array[offset + index] = values[index];
}
return array;
}
function arraySome(array, predicate) {
var length = array == null ? 0 : array.length;
var index = -1;
while (++index < length) {
if (predicate(array[index], index, array)) {
return true;
}
}
return false;
}
function baseTimes(n, iteratee) {
var result = Array(n);
var index = -1;
while (++index < n) {
result[index] = iteratee(index);
}
return result;
}
function cacheHas(cache, key) {
return cache.has(key);
}
function getValue(object, key) {
return object == null ? void 0 : object[key];
}
function mapToArray(map) {
var result = Array(map.size);
var index = -1;
map.forEach(function(value, key) {
result[++index] = [key, value];
});
return result;
}
function overArg(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
function setToArray(set) {
var result = Array(set.size);
var index = -1;
set.forEach(function(value) {
result[++index] = value;
});
return result;
}
var context = root;
var arrayProto = Array.prototype;
var funcProto = Function.prototype;
var objectProto = Object.prototype;
var coreJsData = context["__core-js_shared__"];
var funcToString = funcProto.toString;
var hasOwnProperty = objectProto.hasOwnProperty;
var maskSrcKey = function() {
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
return uid ? "Symbol(src)_1.".concat(uid) : "";
}();
var nativeObjectToString = objectProto.toString;
var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
var Buffer2 = moduleExports ? context.Buffer : void 0;
var Symbol = context.Symbol;
var Uint8Array2 = context.Uint8Array;
var allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
var getPrototype = overArg(Object.getPrototypeOf, Object);
var objectCreate = Object.create;
var propertyIsEnumerable = objectProto.propertyIsEnumerable;
var splice = arrayProto.splice;
var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
var nativeGetSymbols = Object.getOwnPropertySymbols;
var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
var nativeKeys = overArg(Object.keys, Object);
var DataView = getNative(context, "DataView");
var Map = getNative(context, "Map");
var Promise2 = getNative(context, "Promise");
var Set = getNative(context, "Set");
var WeakMap2 = getNative(context, "WeakMap");
var nativeCreate = getNative(Object, "create");
var dataViewCtorString = toSource(DataView);
var mapCtorString = toSource(Map);
var promiseCtorString = toSource(Promise2);
var setCtorString = toSource(Set);
var weakMapCtorString = toSource(WeakMap2);
var symbolProto = Symbol ? Symbol.prototype : void 0;
var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
var baseCreate = function() {
function object() {
}
return function(proto) {
if (!isObject(proto)) {
return {};
}
if (objectCreate) {
return objectCreate(proto);
}
object.prototype = proto;
var result = new object();
object.prototype = void 0;
return result;
};
}();
var Hash = function() {
function Hash2(entries) {
var index = -1;
var length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
Hash2.prototype.clear = function() {
this.__DATA__ = nativeCreate ? nativeCreate(null) : {};
this.size = 0;
};
Hash2.prototype.delete = function(key) {
var result = this.has(key) && delete this.__DATA__[key];
this.size -= result ? 1 : 0;
return result;
};
Hash2.prototype.get = function(key) {
var data = this.__DATA__;
if (nativeCreate) {
var result = data[key];
return result === HASH_UNDEFINED ? void 0 : result;
}
return hasOwnProperty.call(data, key) ? data[key] : void 0;
};
Hash2.prototype.has = function(key) {
var data = this.__DATA__;
return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
};
Hash2.prototype.set = function(key, value) {
var data = this.__DATA__;
this.size += this.has(key) ? 0 : 1;
data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
return this;
};
return Hash2;
}();
var ListCache = function() {
function ListCache2(entries) {
var index = -1;
var length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
ListCache2.prototype.clear = function() {
this.__DATA__ = [];
this.size = 0;
};
ListCache2.prototype.delete = function(key) {
var data = this.__DATA__;
var index = assocIndexOf(data, key);
if (index < 0) {
return false;
}
var lastIndex = data.length - 1;
if (index == lastIndex) {
data.pop();
} else {
splice.call(data, index, 1);
}
--this.size;
return true;
};
ListCache2.prototype.get = function(key) {
var data = this.__DATA__;
var index = assocIndexOf(data, key);
return index < 0 ? void 0 : data[index][1];
};
ListCache2.prototype.has = function(key) {
return assocIndexOf(this.__DATA__, key) > -1;
};
ListCache2.prototype.set = function(key, value) {
var data = this.__DATA__;
var index = assocIndexOf(data, key);
if (index < 0) {
++this.size;
data.push([key, value]);
} else {
data[index][1] = value;
}
return this;
};
return ListCache2;
}();
var MapCache = function() {
function MapCache2(entries) {
var index = -1;
var length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
MapCache2.prototype.clear = function() {
this.size = 0;
this.__DATA__ = {
hash: new Hash(),
map: new (Map || ListCache)(),
string: new Hash()
};
};
MapCache2.prototype.delete = function(key) {
var result = getMapData(this, key)["delete"](key);
this.size -= result ? 1 : 0;
return result;
};
MapCache2.prototype.get = function(key) {
return getMapData(this, key).get(key);
};
MapCache2.prototype.has = function(key) {
return getMapData(this, key).has(key);
};
MapCache2.prototype.set = function(key, value) {
var data = getMapData(this, key);
var size = data.size;
data.set(key, value);
this.size += data.size == size ? 0 : 1;
return this;
};
return MapCache2;
}();
var SetCache = function() {
function SetCache2(values) {
var index = -1;
var length = values == null ? 0 : values.length;
this.__DATA__ = new MapCache();
while (++index < length) {
this.add(values[index]);
}
}
SetCache2.prototype.push = function(value) {
return this.add(value);
};
SetCache2.prototype.add = function(value) {
this.__DATA__.set(value, HASH_UNDEFINED);
return this;
};
SetCache2.prototype.has = function(value) {
return this.__DATA__.has(value);
};
return SetCache2;
}();
var Stack = function() {
function Stack2(entries) {
var data = this.__DATA__ = new ListCache(entries);
this.size = data.size;
}
Stack2.prototype.clear = function() {
this.__DATA__ = new ListCache();
this.size = 0;
};
Stack2.prototype.delete = function(key) {
var data = this.__DATA__;
var result = data["delete"](key);
this.size = data.size;
return result;
};
Stack2.prototype.get = function(key) {
return this.__DATA__.get(key);
};
Stack2.prototype.has = function(key) {
return this.__DATA__.has(key);
};
Stack2.prototype.set = function(key, value) {
var data = this.__DATA__;
if (data instanceof ListCache) {
var pairs = data.__DATA__;
if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
pairs.push([key, value]);
this.size = ++data.size;
return this;
}
data = this.__DATA__ = new MapCache(pairs);
}
data.set(key, value);
this.size = data.size;
return this;
};
return Stack2;
}();
function arrayLikeKeys(value, inherited) {
var isArr = isArray(value);
var isArg = !isArr && isArguments(value);
var isBuff = !isArr && !isArg && isBuffer(value);
var isType = !isArr && !isArg && !isBuff && isTypedArray(value);
var skipIndexes = isArr || isArg || isBuff || isType;
var result = skipIndexes ? baseTimes(value.length, String) : [];
var length = result.length;
for (var key in value) {
if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
result.push(key);
}
}
return result;
}
function assocIndexOf(array, key) {
var length = array.length;
while (length--) {
if (eq(array[length][0], key)) {
return length;
}
}
return -1;
}
function baseAssign(object, source) {
return object && copyObject(source, keys(source), object);
}
function baseAssignIn(object, source) {
return object && copyObject(source, keysIn(source), object);
}
function baseAssignValue(object, key, value) {
if (key == "__proto__" && Object.defineProperty) {
Object.defineProperty(object, key, {
configurable: true,
enumerable: true,
value: value,
writable: true
});
} else {
object[key] = value;
}
}
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
var result = keysFunc(object);
return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
}
function baseGetTag(value) {
if (value == null) {
return value === void 0 ? undefinedTag : nullTag;
}
return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
}
function baseIsArguments(value) {
return isObjectLike(value) && baseGetTag(value) == argsTag;
}
function baseIsEqual(depth, value, other, bitmask, customizer, stack) {
if (depth <= 0) {
throw new Errors_1.RecursionError("Recursive depth reached while comparing object");
}
if (value === other) {
return true;
}
if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
return value !== value && other !== other;
}
return baseIsEqualDeep(depth - 1, value, other, bitmask, customizer, baseIsEqual, stack);
}
function baseIsEqualDeep(depth, object, other, bitmask, customizer, equalFunc, stack) {
var objIsArr = isArray(object);
var othIsArr = isArray(other);
var objTag = objIsArr ? arrayTag : getTag(object);
var othTag = othIsArr ? arrayTag : getTag(other);
objTag = objTag == argsTag ? objectTag : objTag;
othTag = othTag == argsTag ? objectTag : othTag;
var objIsObj = objTag == objectTag;
var othIsObj = othTag == objectTag;
var isSameTag = objTag == othTag;
if (isSameTag && isBuffer(object)) {
if (!isBuffer(other)) {
return false;
}
objIsArr = true;
objIsObj = false;
}
if (isSameTag && !objIsObj) {
stack = !stack ? new Stack() : stack;
return objIsArr || isTypedArray(object) ? equalArrays(depth, object, other, bitmask, customizer, equalFunc, stack) : equalByTag(depth, object, other, objTag, bitmask, customizer, equalFunc, stack);
}
if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__");
var othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
if (objIsWrapped || othIsWrapped) {
var objUnwrapped = objIsWrapped ? object.value() : object;
var othUnwrapped = othIsWrapped ? other.value() : other;
stack = !stack ? new Stack() : stack;
return equalFunc(depth, objUnwrapped, othUnwrapped, bitmask, customizer, stack);
}
}
if (!isSameTag) {
return false;
}
stack = !stack ? new Stack() : stack;
return equalObjects(depth, object, other, bitmask, customizer, equalFunc, stack);
}
function baseIsMap(value) {
return isObjectLike(value) && getTag(value) == mapTag;
}
function baseIsNative(value) {
if (!isObject(value) || isMasked(value)) {
return false;
}
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
return pattern.test(toSource(value));
}
function baseIsSet(value) {
return isObjectLike(value) && getTag(value) == setTag;
}
function baseIsTypedArray(value) {
return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
}
function baseKeys(object) {
if (!isPrototype(object)) {
return nativeKeys(object);
}
var result = [];
for (var key in Object(object)) {
if (hasOwnProperty.call(object, key) && key != "constructor") {
result.push(key);
}
}
return result;
}
function baseKeysIn(object) {
if (!isObject(object)) {
return nativeKeysIn(object);
}
var isProto = isPrototype(object);
var result = [];
for (var key in object) {
if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
result.push(key);
}
}
return result;
}
function cloneBuffer(buffer, isDeep) {
if (isDeep) {
return buffer.slice();
}
var length = buffer.length;
var ctor = buffer.constructor;
var result = allocUnsafe ? allocUnsafe(length) : new ctor(length);
buffer.copy(result);
return result;
}
function cloneArrayBuffer(arrayBuffer) {
var ctor = arrayBuffer["constructor"];
var result = new ctor(arrayBuffer.byteLength);
new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
return result;
}
function cloneDataView(dataView, isDeep) {
var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
}
function cloneRegExp(regexp) {
var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
result.lastIndex = regexp.lastIndex;
return result;
}
function cloneSymbol(symbol) {
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
}
function cloneTypedArray(typedArray, isDeep) {
var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
}
function copyArray(source, array) {
var index = -1;
var length = source.length;
array = !array ? Array(length) : array;
while (++index < length) {
array[index] = source[index];
}
return array;
}
function copyObject(source, props, object, customizer) {
var isNew = !object;
object = isNew ? {} : object;
var index = -1;
var length = props.length;
while (++index < length) {
var key = props[index];
var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
if (newValue === void 0) {
newValue = source[key];
}
if (isNew) {
baseAssignValue(object, key, newValue);
} else {
assignValue(object, key, newValue);
}
}
return object;
}
function copySymbols(source, object) {
return copyObject(source, getSymbols(source), object);
}
function copySymbolsIn(source, object) {
return copyObject(source, getSymbolsIn(source), object);
}
function equalArrays(depth, array, other, bitmask, customizer, equalFunc, stack) {
var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
var arrLength = array.length;
var othLength = other.length;
if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
return false;
}
var stacked = stack.get(array);
if (stacked && stack.get(other)) {
return stacked == other;
}
var index = -1;
var result = true;
var seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
stack.set(array, other);
stack.set(other, array);
var _loop_1 = function() {
var arrValue = array[index];
var othValue = other[index];
var compared = void 0;
if (customizer) {
compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
}
if (compared !== void 0) {
if (compared) {
return "continue";
}
result = false;
return "break";
}
if (seen) {
if (!arraySome(other, function(othValue2, othIndex) {
if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(depth, arrValue, othValue2, bitmask, customizer, stack))) {
return seen.push(othIndex);
}
})) {
result = false;
return "break";
}
} else if (!(arrValue === othValue || equalFunc(depth, arrValue, othValue, bitmask, customizer, stack))) {
result = false;
return "break";
}
};
while (++index < arrLength) {
var state_1 = _loop_1();
if (state_1 === "break")
break;
}
stack["delete"](array);
stack["delete"](other);
return result;
}
function equalByTag(depth, object, other, tag, bitmask, customizer, equalFunc, stack) {
var convert;
switch (tag) {
case dataViewTag:
if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
return false;
}
object = object.buffer;
other = other.buffer;
case arrayBufferTag:
if (object.byteLength != other.byteLength || !equalFunc(depth, new Uint8Array2(object), new Uint8Array2(other))) {
return false;
}
return true;
case boolTag:
case dateTag:
case numberTag:
return eq(+object, +other);
case errorTag:
return object.name == other.name && object.message == other.message;
case regexpTag:
case stringTag:
return object == other + "";
case mapTag:
convert = mapToArray;
case setTag:
var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
convert = !convert ? setToArray : convert;
if (object.size != other.size && !isPartial) {
return false;
}
var stacked = stack.get(object);
if (stacked) {
return stacked == other;
}
bitmask |= COMPARE_UNORDERED_FLAG;
stack.set(object, other);
var result = equalArrays(depth, convert(object), convert(other), bitmask, customizer, equalFunc, stack);
stack["delete"](object);
return result;
case symbolTag:
if (symbolValueOf) {
return symbolValueOf.call(object) == symbolValueOf.call(other);
}
}
return false;
}
function equalObjects(depth, object, other, bitmask, customizer, equalFunc, stack) {
var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
var objProps = getAllKeys(object);
var objLength = objProps.length;
var othProps = getAllKeys(other);
var othLength = othProps.length;
if (objLength != othLength && !isPartial) {
return false;
}
var index = objLength;
while (index--) {
var key = objProps[index];
if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
return false;
}
}
var stacked = stack.get(object);
if (stacked && stack.get(other)) {
return stacked == other;
}
var result = true;
stack.set(object, other);
stack.set(other, object);
var skipCtor = !!isPartial;
while (++index < objLength) {
var key = objProps[index];
var objValue = object[key];
var othValue = other[key];
var compared = void 0;
if (customizer) {
compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
}
if (!(compared === void 0 ? objValue === othValue || equalFunc(depth, objValue, othValue, bitmask, customizer, stack) : compared)) {
result = false;
break;
}
skipCtor = !skipCtor ? key == "constructor" : skipCtor;
}
if (result && !skipCtor) {
var objCtor = object.constructor;
var othCtor = other.constructor;
if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
result = false;
}
}
stack["delete"](object);
stack["delete"](other);
return result;
}
function getAllKeys(object) {
return baseGetAllKeys(object, keys, getSymbols);
}
function getAllKeysIn(object) {
return baseGetAllKeys(object, keysIn, getSymbolsIn);
}
function getMapData(map, key) {
var data = map.__DATA__;
return isKeyable(key) ? data[typeof key === "string" ? "string" : "hash"] : data.map;
}
function getNative(object, key) {
var value = getValue(object, key);
return baseIsNative(value) ? value : void 0;
}
function getRawTag(value) {
var isOwn = hasOwnProperty.call(value, symToStringTag);
var tag = value[symToStringTag];
var unmasked = false;
try {
value[symToStringTag] = void 0;
unmasked = true;
} catch (e) {
}
var result = nativeObjectToString.call(value);
if (unmasked) {
if (isOwn) {
value[symToStringTag] = tag;
} else {
delete value[symToStringTag];
}
}
return result;
}
var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
if (object == null) {
return [];
}
object = Object(object);
return arrayFilter(nativeGetSymbols(object), function(symbol) {
return propertyIsEnumerable.call(object, symbol);
});
};
var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
var result = [];
while (object) {
arrayPush(result, getSymbols(object));
object = getPrototype(object);
}
return result;
};
var getTag = baseGetTag;
if (DataView && getTag(new DataView(new ArrayBuffer(1))) !== dataViewTag || Map && getTag(new Map()) !== mapTag || Promise2 && getTag(Promise2.resolve()) !== promiseTag || Set && getTag(new Set()) !== setTag || WeakMap2 && getTag(new WeakMap2()) !== weakMapTag) {
getTag = function(value) {
var result = baseGetTag(value);
var Ctor = result === objectTag ? value.constructor : void 0;
var ctorString = Ctor ? toSource(Ctor) : "";
if (ctorString) {
switch (ctorString) {
case dataViewCtorString:
return dataViewTag;
case mapCtorString:
return mapTag;
case promiseCtorString:
return promiseTag;
case setCtorString:
return setTag;
case weakMapCtorString:
return weakMapTag;
}
}
return result;
};
}
function initCloneArray(array) {
var length = array.length;
var result = new array.constructor(length);
if (length && typeof array[0] === "string" && hasOwnProperty.call(array, "index")) {
result.index = array.index;
result.input = array.input;
}
return result;
}
function initCloneObject(object) {
return typeof object.constructor === "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
}
function initCloneByTag(object, tag, isDeep) {
var Ctor = object.constructor;
switch (tag) {
case arrayBufferTag:
return cloneArrayBuffer(object);
case boolTag:
case dateTag:
return new Ctor(+object);
case dataViewTag:
return cloneDataView(object, isDeep);
case float32Tag:
case float64Tag:
case int8Tag:
case int16Tag:
case int32Tag:
case uint8Tag:
case uint8ClampedTag:
case uint16Tag:
case uint32Tag:
return cloneTypedArray(object, isDeep);
case mapTag:
return new Ctor();
case numberTag:
case stringTag:
return new Ctor(object);
case regexpTag:
return cloneRegExp(object);
case setTag:
return new Ctor();
case symbolTag:
return cloneSymbol(object);
}
}
function isIndex(value, length) {
var type = typeof value;
length = length == null ? MAX_SAFE_INTEGER : length;
return !!length && (type === "number" || type !== "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 === 0 && value < length);
}
function isKeyable(value) {
var type = typeof value;
return type === "string" || type === "number" || type === "symbol" || type === "boolean" ? value !== "__proto__" : value === null;
}
function isMasked(func) {
return !!maskSrcKey && maskSrcKey in func;
}
function isPrototype(value) {
var Ctor = value && value.constructor;
var proto = typeof Ctor === "function" && Ctor.prototype || objectProto;
return value === proto;
}
function nativeKeysIn(object) {
var result = [];
if (object != null) {
for (var key in Object(object)) {
result.push(key);
}
}
return result;
}
function objectToString(value) {
return nativeObjectToString.call(value);
}
function toSource(func) {
if (func != null) {
try {
return funcToString.call(func);
} catch (e) {
}
try {
return func + "";
} catch (e) {
}
}
return "";
}
function memoize(func, resolver) {
if (typeof func !== "function" || resolver != null && typeof resolver !== "function") {
throw new TypeError(FUNC_ERROR_TEXT);
}
var memoized = function() {
var args = arguments;
var key = resolver ? resolver.apply(this, args) : args[0];
var cache = memoized["cache"];
if (cache.has(key)) {
return cache.get(key);
}
var result = func.apply(this, args);
memoized["cache"] = cache.set(key, result) || cache;
return result;
};
memoized["cache"] = new (memoize.Cache || MapCache)();
return memoized;
}
memoize.Cache = MapCache;
function eq(value, other) {
return value === other || value !== value && other !== other;
}
var isArguments = baseIsArguments(function() {
return arguments;
}()) ? baseIsArguments : function(value) {
return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
};
var isArray = Array.isArray;
function isArrayLike(value) {
return value != null && isLength(value.length) && !isFunction(value);
}
var isBuffer = nativeIsBuffer || stubFalse;
function isEqual(depth, value, other) {
return baseIsEqual(depth, value, other);
}
exports.isEqual = isEqual;
function isFunction(value) {
if (!isObject(value)) {
return false;
}
var tag = baseGetTag(value);
return tag === funcTag || tag === genTag || tag === asyncTag || tag === proxyTag;
}
function isLength(value) {
return typeof value === "number" && value > -1 && value % 1 === 0 && value <= MAX_SAFE_INTEGER;
}
function isObject(value) {
var type = typeof value;
return value != null && (type === "object" || type === "function");
}
function isObjectLike(value) {
return value != null && typeof value === "object";
}
var isMap = baseIsMap;
var isSet = baseIsSet;
var isTypedArray = baseIsTypedArray;
function keys(object) {
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
}
function keysIn(object) {
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
}
function stubArray() {
return [];
}
function stubFalse() {
return false;
}
function assignValue(object, key, value) {
var objValue = object[key];
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
baseAssignValue(object, key, value);
}
}
function baseClone(depth, value, bitmask, customizer, key, object, stack) {
if (depth <= 0) {
t