testcafe 3.7.4 → 3.7.5

package/lib/utils/replicator/index.js

@@ -0,0 +1,442 @@
+"use strict";
+/* eslint-disable no-var */
+Object.defineProperty(exports, "__esModule", { value: true });
+// Const
+var TRANSFORMED_TYPE_KEY = '@t';
+var CIRCULAR_REF_KEY = '@r';
+var KEY_REQUIRE_ESCAPING_RE = /^#*@(t|r)$/;
+var TYPED_ARRAY_CTORS = {
+    'Int8Array': typeof Int8Array === 'function' ? Int8Array : void 0,
+    'Uint8Array': typeof Uint8Array === 'function' ? Uint8Array : void 0,
+    'Uint8ClampedArray': typeof Uint8ClampedArray === 'function' ? Uint8ClampedArray : void 0,
+    'Int16Array': typeof Int16Array === 'function' ? Int16Array : void 0,
+    'Uint16Array': typeof Uint16Array === 'function' ? Uint16Array : void 0,
+    'Int32Array': typeof Int32Array === 'function' ? Int32Array : void 0,
+    'Uint32Array': typeof Uint32Array === 'function' ? Uint32Array : void 0,
+    'Float32Array': typeof Float32Array === 'function' ? Float32Array : void 0,
+    'Float64Array': typeof Float64Array === 'function' ? Float64Array : void 0,
+};
+var SAFE_ERROR_CTORS = {
+    'Error': Error,
+    'EvalError': EvalError,
+    'RangeError': RangeError,
+    'ReferenceError': ReferenceError,
+    'SyntaxError': SyntaxError,
+    'TypeError': TypeError,
+    'URIError': URIError,
+};
+var ARRAY_BUFFER_SUPPORTED = typeof ArrayBuffer === 'function';
+var MAP_SUPPORTED = typeof Map === 'function';
+var SET_SUPPORTED = typeof Set === 'function';
+var BUFFER_FROM_SUPPORTED = typeof Buffer === 'function';
+var TYPED_ARRAY_SUPPORTED = function (typeName) {
+    return !!TYPED_ARRAY_CTORS[typeName];
+};
+// Saved proto functions
+var arrSlice = Array.prototype.slice;
+// Default serializer
+var JSONSerializer = {
+    serialize: function (val) {
+        return JSON.stringify(val);
+    },
+    deserialize: function (val) {
+        return JSON.parse(val);
+    },
+};
+// EncodingTransformer
+var EncodingTransformer = function (val, transforms) {
+    this.references = val;
+    this.transforms = transforms;
+    this.circularCandidates = [];
+    this.circularCandidatesDescrs = [];
+    this.circularRefCount = 0;
+};
+EncodingTransformer._createRefMark = function (idx) {
+    var obj = Object.create(null);
+    obj[CIRCULAR_REF_KEY] = idx;
+    return obj;
+};
+EncodingTransformer.prototype._createCircularCandidate = function (val, parent, key) {
+    this.circularCandidates.push(val);
+    this.circularCandidatesDescrs.push({ parent: parent, key: key, refIdx: -1 });
+};
+EncodingTransformer.prototype._applyTransform = function (val, parent, key, transform) {
+    var result = Object.create(null);
+    var serializableVal = transform.toSerializable(val);
+    if (typeof serializableVal === 'object')
+        this._createCircularCandidate(val, parent, key);
+    result[TRANSFORMED_TYPE_KEY] = transform.type;
+    result.data = this._handleValue(serializableVal, parent, key);
+    return result;
+};
+EncodingTransformer.prototype._handleArray = function (arr) {
+    var result = [];
+    for (var i = 0; i < arr.length; i++)
+        result[i] = this._handleValue(arr[i], result, i);
+    return result;
+};
+EncodingTransformer.prototype._handlePlainObject = function (obj) {
+    var replicator = this;
+    var result = Object.create(null);
+    var ownPropertyNames = Object.getOwnPropertyNames(obj);
+    ownPropertyNames.forEach(key => {
+        var resultKey = KEY_REQUIRE_ESCAPING_RE.test(key) ? '#' + key : key;
+        result[resultKey] = replicator._handleValue(obj[key], result, resultKey);
+    });
+    return result;
+};
+EncodingTransformer.prototype._handleObject = function (obj, parent, key) {
+    this._createCircularCandidate(obj, parent, key);
+    return Array.isArray(obj) ? this._handleArray(obj) : this._handlePlainObject(obj);
+};
+EncodingTransformer.prototype._ensureCircularReference = function (obj) {
+    var circularCandidateIdx = this.circularCandidates.indexOf(obj);
+    if (circularCandidateIdx > -1) {
+        var descr = this.circularCandidatesDescrs[circularCandidateIdx];
+        if (descr.refIdx === -1)
+            descr.refIdx = descr.parent ? ++this.circularRefCount : 0;
+        return EncodingTransformer._createRefMark(descr.refIdx);
+    }
+    return null;
+};
+EncodingTransformer.prototype._handleValue = function (val, parent, key) {
+    var type = typeof val;
+    var isObject = type === 'object' && val !== null;
+    if (isObject) {
+        var refMark = this._ensureCircularReference(val);
+        if (refMark)
+            return refMark;
+    }
+    for (var i = 0; i < this.transforms.length; i++) {
+        var transform = this.transforms[i];
+        if (transform.shouldTransform(type, val))
+            return this._applyTransform(val, parent, key, transform);
+    }
+    if (isObject)
+        return this._handleObject(val, parent, key);
+    return val;
+};
+EncodingTransformer.prototype.transform = function () {
+    var references = [this._handleValue(this.references, null, null)];
+    for (var i = 0; i < this.circularCandidatesDescrs.length; i++) {
+        var descr = this.circularCandidatesDescrs[i];
+        if (descr.refIdx > 0) {
+            references[descr.refIdx] = descr.parent[descr.key];
+            descr.parent[descr.key] = EncodingTransformer._createRefMark(descr.refIdx);
+        }
+    }
+    return references;
+};
+// DecodingTransformer
+var DecodingTransformer = function (references, transformsMap) {
+    this.references = references;
+    this.transformMap = transformsMap;
+    this.activeTransformsStack = [];
+    this.visitedRefs = Object.create(null);
+};
+DecodingTransformer.prototype._handlePlainObject = function (obj) {
+    var replicator = this;
+    var unescaped = Object.create(null);
+    var ownPropertyNames = Object.getOwnPropertyNames(obj);
+    ownPropertyNames.forEach(key => {
+        replicator._handleValue(obj[key], obj, key);
+        if (KEY_REQUIRE_ESCAPING_RE.test(key)) {
+            // NOTE: use intermediate object to avoid unescaped and escaped keys interference
+            // E.g. unescaped "##@t" will be "#@t" which can overwrite escaped "#@t".
+            unescaped[key.substring(1)] = obj[key];
+            delete obj[key];
+        }
+    });
+    for (var unescapedKey in unescaped)
+        obj[unescapedKey] = unescaped[unescapedKey];
+};
+DecodingTransformer.prototype._handleTransformedObject = function (obj, parent, key) {
+    var transformType = obj[TRANSFORMED_TYPE_KEY];
+    var transform = this.transformMap[transformType];
+    if (!transform)
+        throw new Error('Can\'t find transform for "' + transformType + '" type.');
+    this.activeTransformsStack.push(obj);
+    this._handleValue(obj.data, obj, 'data');
+    this.activeTransformsStack.pop();
+    parent[key] = transform.fromSerializable(obj.data);
+};
+DecodingTransformer.prototype._handleCircularSelfRefDuringTransform = function (refIdx, parent, key) {
+    // NOTE: we've hit a hard case: object reference itself during transformation.
+    // We can't dereference it since we don't have resulting object yet. And we'll
+    // not be able to restore reference lately because we will need to traverse
+    // transformed object again and reference might be unreachable or new object contain
+    // new circular references. As a workaround we create getter, so once transformation
+    // complete, dereferenced property will point to correct transformed object.
+    var references = this.references;
+    var val = void 0;
+    Object.defineProperty(parent, key, {
+        configurable: true,
+        enumerable: true,
+        get: function () {
+            if (val === void 0)
+                val = references[refIdx];
+            return val;
+        },
+        set: function (value) {
+            val = value;
+            // eslint-disable-next-line no-setter-return
+            return val;
+        },
+    });
+};
+DecodingTransformer.prototype._handleCircularRef = function (refIdx, parent, key) {
+    if (this.activeTransformsStack.indexOf(this.references[refIdx]) > -1)
+        this._handleCircularSelfRefDuringTransform(refIdx, parent, key);
+    else {
+        if (!this.visitedRefs[refIdx]) {
+            this.visitedRefs[refIdx] = true;
+            this._handleValue(this.references[refIdx], this.references, refIdx);
+        }
+        parent[key] = this.references[refIdx];
+    }
+};
+DecodingTransformer.prototype._handleValue = function (val, parent, key) {
+    if (typeof val !== 'object' || val === null)
+        return;
+    var refIdx = val[CIRCULAR_REF_KEY];
+    if (refIdx !== void 0)
+        this._handleCircularRef(refIdx, parent, key);
+    else if (val[TRANSFORMED_TYPE_KEY])
+        this._handleTransformedObject(val, parent, key);
+    else if (Array.isArray(val)) {
+        for (var i = 0; i < val.length; i++)
+            this._handleValue(val[i], val, i);
+    }
+    else
+        this._handlePlainObject(val);
+};
+DecodingTransformer.prototype.transform = function () {
+    this.visitedRefs[0] = true;
+    this._handleValue(this.references[0], this.references, 0);
+    return this.references[0];
+};
+// Transforms
+var builtInTransforms = [
+    {
+        type: '[[NaN]]',
+        shouldTransform: function (type, val) {
+            return type === 'number' && isNaN(val);
+        },
+        toSerializable: function () {
+            return '';
+        },
+        fromSerializable: function () {
+            return NaN;
+        },
+    },
+    {
+        type: '[[undefined]]',
+        shouldTransform: function (type) {
+            return type === 'undefined';
+        },
+        toSerializable: function () {
+            return '';
+        },
+        fromSerializable: function () {
+            return void 0;
+        },
+    },
+    {
+        type: '[[Date]]',
+        shouldTransform: function (type, val) {
+            return val instanceof Date;
+        },
+        toSerializable: function (date) {
+            return date.getTime();
+        },
+        fromSerializable: function (val) {
+            var date = new Date();
+            date.setTime(val);
+            return date;
+        },
+    },
+    {
+        type: '[[RegExp]]',
+        shouldTransform: function (type, val) {
+            return val instanceof RegExp;
+        },
+        toSerializable: function (re) {
+            var result = {
+                src: re.source,
+                flags: '',
+            };
+            if (re.global)
+                result.flags += 'g';
+            if (re.ignoreCase)
+                result.flags += 'i';
+            if (re.multiline)
+                result.flags += 'm';
+            return result;
+        },
+        fromSerializable: function (val) {
+            return new RegExp(val.src, val.flags);
+        },
+    },
+    {
+        type: '[[Error]]',
+        shouldTransform: function (type, val) {
+            return val instanceof Error;
+        },
+        toSerializable: function (err) {
+            return {
+                name: err.name,
+                message: err.message,
+                stack: err.stack,
+            };
+        },
+        fromSerializable: function (val) {
+            var Ctor = SAFE_ERROR_CTORS[val.name] || Error;
+            var err = new Ctor(val.message);
+            err.stack = val.stack;
+            return err;
+        },
+    },
+    {
+        type: '[[ArrayBuffer]]',
+        shouldTransform: function (type, val) {
+            return ARRAY_BUFFER_SUPPORTED && val instanceof ArrayBuffer;
+        },
+        toSerializable: function (buffer) {
+            var view = new Int8Array(buffer);
+            return arrSlice.call(view);
+        },
+        fromSerializable: function (val) {
+            if (ARRAY_BUFFER_SUPPORTED) {
+                var buffer = new ArrayBuffer(val.length);
+                var view = new Int8Array(buffer);
+                view.set(val);
+                return buffer;
+            }
+            return val;
+        },
+    },
+    {
+        type: '[[Buffer]]',
+        shouldTransform: function (type, val) {
+            return BUFFER_FROM_SUPPORTED && val instanceof Buffer;
+        },
+        toSerializable: function (buffer) {
+            return arrSlice.call(buffer);
+        },
+        fromSerializable: function (val) {
+            if (BUFFER_FROM_SUPPORTED)
+                return Buffer.from(val);
+            return val;
+        },
+    },
+    {
+        type: '[[TypedArray]]',
+        shouldTransform: function (type, val) {
+            return Object.keys(TYPED_ARRAY_CTORS).some(ctorName => {
+                return TYPED_ARRAY_SUPPORTED(ctorName) && val instanceof TYPED_ARRAY_CTORS[ctorName];
+            });
+        },
+        toSerializable: function (arr) {
+            return {
+                ctorName: arr.constructor.name,
+                arr: arrSlice.call(arr),
+            };
+        },
+        fromSerializable: function (val) {
+            return TYPED_ARRAY_SUPPORTED(val.ctorName) ? new TYPED_ARRAY_CTORS[val.ctorName](val.arr) : val.arr;
+        },
+    },
+    {
+        type: '[[Map]]',
+        shouldTransform: function (type, val) {
+            return MAP_SUPPORTED && val instanceof Map;
+        },
+        toSerializable: function (map) {
+            var flattenedKVArr = [];
+            map.forEach((val, key) => {
+                flattenedKVArr.push(key);
+                flattenedKVArr.push(val);
+            });
+            return flattenedKVArr;
+        },
+        fromSerializable: function (val) {
+            if (MAP_SUPPORTED) {
+                // NOTE: new Map(iterable) is not supported by all browsers
+                var map = new Map();
+                for (var i = 0; i < val.length; i += 2)
+                    map.set(val[i], val[i + 1]);
+                return map;
+            }
+            var kvArr = [];
+            for (var j = 0; j < val.length; j += 2)
+                kvArr.push([val[j], val[j + 1]]);
+            return kvArr;
+        },
+    },
+    {
+        type: '[[Set]]',
+        shouldTransform: function (type, val) {
+            return SET_SUPPORTED && val instanceof Set;
+        },
+        toSerializable: function (set) {
+            var arr = [];
+            set.forEach(val => {
+                arr.push(val);
+            });
+            return arr;
+        },
+        fromSerializable: function (val) {
+            if (SET_SUPPORTED) {
+                // NOTE: new Set(iterable) is not supported by all browsers
+                var set = new Set();
+                for (var i = 0; i < val.length; i++)
+                    set.add(val[i]);
+                return set;
+            }
+            return val;
+        },
+    },
+];
+// Replicator
+var Replicator = function (serializer) {
+    this.transforms = [];
+    this.transformsMap = Object.create(null);
+    this.serializer = serializer || JSONSerializer;
+    this.addTransforms(builtInTransforms);
+};
+// Manage transforms
+Replicator.prototype.addTransforms = function (transforms) {
+    transforms = Array.isArray(transforms) ? transforms : [transforms];
+    for (var i = 0; i < transforms.length; i++) {
+        var transform = transforms[i];
+        if (this.transformsMap[transform.type])
+            throw new Error('Transform with type "' + transform.type + '" was already added.');
+        this.transforms.push(transform);
+        this.transformsMap[transform.type] = transform;
+    }
+    return this;
+};
+Replicator.prototype.removeTransforms = function (transforms) {
+    transforms = Array.isArray(transforms) ? transforms : [transforms];
+    for (var i = 0; i < transforms.length; i++) {
+        var transform = transforms[i];
+        var idx = this.transforms.indexOf(transform);
+        if (idx > -1)
+            this.transforms.splice(idx, 1);
+        delete this.transformsMap[transform.type];
+    }
+    return this;
+};
+Replicator.prototype.encode = function (val) {
+    var transformer = new EncodingTransformer(val, this.transforms);
+    var references = transformer.transform();
+    return this.serializer.serialize(references);
+};
+Replicator.prototype.decode = function (val) {
+    var references = this.serializer.deserialize(val);
+    var transformer = new DecodingTransformer(references, this.transformsMap);
+    return transformer.transform();
+};
+exports.default = Replicator;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/replicator/index.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-var */\n\n// Const\nvar TRANSFORMED_TYPE_KEY    = '@t';\nvar CIRCULAR_REF_KEY        = '@r';\nvar KEY_REQUIRE_ESCAPING_RE = /^#*@(t|r)$/;\n\nvar TYPED_ARRAY_CTORS = {\n    'Int8Array':         typeof Int8Array === 'function' ? Int8Array : void 0,\n    'Uint8Array':        typeof Uint8Array === 'function' ? Uint8Array : void 0,\n    'Uint8ClampedArray': typeof Uint8ClampedArray === 'function' ? Uint8ClampedArray : void 0,\n    'Int16Array':        typeof Int16Array === 'function' ? Int16Array : void 0,\n    'Uint16Array':       typeof Uint16Array === 'function' ? Uint16Array : void 0,\n    'Int32Array':        typeof Int32Array === 'function' ? Int32Array : void 0,\n    'Uint32Array':       typeof Uint32Array === 'function' ? Uint32Array : void 0,\n    'Float32Array':      typeof Float32Array === 'function' ? Float32Array : void 0,\n    'Float64Array':      typeof Float64Array === 'function' ? Float64Array : void 0,\n};\n\nvar SAFE_ERROR_CTORS = {\n    'Error':          Error,\n    'EvalError':      EvalError,\n    'RangeError':     RangeError,\n    'ReferenceError': ReferenceError,\n    'SyntaxError':    SyntaxError,\n    'TypeError':      TypeError,\n    'URIError':       URIError,\n};\n\nvar ARRAY_BUFFER_SUPPORTED = typeof ArrayBuffer === 'function';\nvar MAP_SUPPORTED          = typeof Map === 'function';\nvar SET_SUPPORTED          = typeof Set === 'function';\nvar BUFFER_FROM_SUPPORTED  = typeof Buffer === 'function';\n\nvar TYPED_ARRAY_SUPPORTED = function (typeName) {\n    return !!TYPED_ARRAY_CTORS[typeName];\n};\n\n// Saved proto functions\nvar arrSlice = Array.prototype.slice;\n\n// Default serializer\nvar JSONSerializer = {\n    serialize: function (val) {\n        return JSON.stringify(val);\n    },\n\n    deserialize: function (val) {\n        return JSON.parse(val);\n    },\n};\n\n// EncodingTransformer\nvar EncodingTransformer = function (val, transforms) {\n    this.references               = val;\n    this.transforms               = transforms;\n    this.circularCandidates       = [];\n    this.circularCandidatesDescrs = [];\n    this.circularRefCount         = 0;\n};\n\nEncodingTransformer._createRefMark = function (idx) {\n    var obj = Object.create(null);\n\n    obj[CIRCULAR_REF_KEY] = idx;\n\n    return obj;\n};\n\nEncodingTransformer.prototype._createCircularCandidate = function (val, parent, key) {\n    this.circularCandidates.push(val);\n    this.circularCandidatesDescrs.push({ parent: parent, key: key, refIdx: -1 });\n};\n\nEncodingTransformer.prototype._applyTransform = function (val, parent, key, transform) {\n    var result          = Object.create(null);\n    var serializableVal = transform.toSerializable(val);\n\n    if (typeof serializableVal === 'object')\n        this._createCircularCandidate(val, parent, key);\n\n    result[TRANSFORMED_TYPE_KEY] = transform.type;\n    result.data                  = this._handleValue(serializableVal, parent, key);\n\n    return result;\n};\n\nEncodingTransformer.prototype._handleArray = function (arr) {\n    var result = [];\n\n    for (var i = 0; i < arr.length; i++)\n        result[i] = this._handleValue(arr[i], result, i);\n\n    return result;\n};\n\nEncodingTransformer.prototype._handlePlainObject = function (obj) {\n    var replicator       = this;\n    var result           = Object.create(null);\n    var ownPropertyNames = Object.getOwnPropertyNames(obj);\n\n    ownPropertyNames.forEach(key => {\n        var resultKey = KEY_REQUIRE_ESCAPING_RE.test(key) ? '#' + key : key;\n\n        result[resultKey] = replicator._handleValue(obj[key], result, resultKey);\n    });\n\n    return result;\n};\n\nEncodingTransformer.prototype._handleObject = function (obj, parent, key) {\n    this._createCircularCandidate(obj, parent, key);\n\n    return Array.isArray(obj) ? this._handleArray(obj) : this._handlePlainObject(obj);\n};\n\nEncodingTransformer.prototype._ensureCircularReference = function (obj) {\n    var circularCandidateIdx = this.circularCandidates.indexOf(obj);\n\n    if (circularCandidateIdx > -1) {\n        var descr = this.circularCandidatesDescrs[circularCandidateIdx];\n\n        if (descr.refIdx === -1)\n            descr.refIdx = descr.parent ? ++this.circularRefCount : 0;\n\n        return EncodingTransformer._createRefMark(descr.refIdx);\n    }\n\n    return null;\n};\n\nEncodingTransformer.prototype._handleValue = function (val, parent, key) {\n    var type     = typeof val;\n    var isObject = type === 'object' && val !== null;\n\n    if (isObject) {\n        var refMark = this._ensureCircularReference(val);\n\n        if (refMark)\n            return refMark;\n    }\n\n    for (var i = 0; i < this.transforms.length; i++) {\n        var transform = this.transforms[i];\n\n        if (transform.shouldTransform(type, val))\n            return this._applyTransform(val, parent, key, transform);\n    }\n\n    if (isObject)\n        return this._handleObject(val, parent, key);\n\n    return val;\n};\n\nEncodingTransformer.prototype.transform = function () {\n    var references = [this._handleValue(this.references, null, null)];\n\n    for (var i = 0; i < this.circularCandidatesDescrs.length; i++) {\n        var descr = this.circularCandidatesDescrs[i];\n\n        if (descr.refIdx > 0) {\n            references[descr.refIdx] = descr.parent[descr.key];\n            descr.parent[descr.key]  = EncodingTransformer._createRefMark(descr.refIdx);\n        }\n    }\n\n    return references;\n};\n\n// DecodingTransformer\nvar DecodingTransformer = function (references, transformsMap) {\n    this.references            = references;\n    this.transformMap          = transformsMap;\n    this.activeTransformsStack = [];\n    this.visitedRefs           = Object.create(null);\n};\n\nDecodingTransformer.prototype._handlePlainObject = function (obj) {\n    var replicator       = this;\n    var unescaped        = Object.create(null);\n    var ownPropertyNames = Object.getOwnPropertyNames(obj);\n\n    ownPropertyNames.forEach(key => {\n        replicator._handleValue(obj[key], obj, key);\n\n        if (KEY_REQUIRE_ESCAPING_RE.test(key)) {\n            // NOTE: use intermediate object to avoid unescaped and escaped keys interference\n            // E.g. unescaped \"##@t\" will be \"#@t\" which can overwrite escaped \"#@t\".\n            unescaped[key.substring(1)] = obj[key];\n            delete obj[key];\n        }\n    });\n\n    for (var unescapedKey in unescaped)\n        obj[unescapedKey] = unescaped[unescapedKey];\n};\n\nDecodingTransformer.prototype._handleTransformedObject = function (obj, parent, key) {\n    var transformType = obj[TRANSFORMED_TYPE_KEY];\n    var transform     = this.transformMap[transformType];\n\n    if (!transform)\n        throw new Error('Can\\'t find transform for \"' + transformType + '\" type.');\n\n    this.activeTransformsStack.push(obj);\n    this._handleValue(obj.data, obj, 'data');\n    this.activeTransformsStack.pop();\n\n    parent[key] = transform.fromSerializable(obj.data);\n};\n\nDecodingTransformer.prototype._handleCircularSelfRefDuringTransform = function (refIdx, parent, key) {\n    // NOTE: we've hit a hard case: object reference itself during transformation.\n    // We can't dereference it since we don't have resulting object yet. And we'll\n    // not be able to restore reference lately because we will need to traverse\n    // transformed object again and reference might be unreachable or new object contain\n    // new circular references. As a workaround we create getter, so once transformation\n    // complete, dereferenced property will point to correct transformed object.\n    var references = this.references;\n    var val        = void 0;\n\n    Object.defineProperty(parent, key, {\n        configurable: true,\n        enumerable:   true,\n\n        get: function () {\n            if (val === void 0)\n                val = references[refIdx];\n\n            return val;\n        },\n\n        set: function (value) {\n            val = value;\n\n            // eslint-disable-next-line no-setter-return\n            return val;\n        },\n    });\n};\n\nDecodingTransformer.prototype._handleCircularRef = function (refIdx, parent, key) {\n    if (this.activeTransformsStack.indexOf(this.references[refIdx]) > -1)\n        this._handleCircularSelfRefDuringTransform(refIdx, parent, key);\n\n    else {\n        if (!this.visitedRefs[refIdx]) {\n            this.visitedRefs[refIdx] = true;\n            this._handleValue(this.references[refIdx], this.references, refIdx);\n        }\n\n        parent[key] = this.references[refIdx];\n    }\n};\n\nDecodingTransformer.prototype._handleValue = function (val, parent, key) {\n    if (typeof val !== 'object' || val === null)\n        return;\n\n    var refIdx = val[CIRCULAR_REF_KEY];\n\n    if (refIdx !== void 0)\n        this._handleCircularRef(refIdx, parent, key);\n\n    else if (val[TRANSFORMED_TYPE_KEY])\n        this._handleTransformedObject(val, parent, key);\n\n    else if (Array.isArray(val)) {\n        for (var i = 0; i < val.length; i++)\n            this._handleValue(val[i], val, i);\n    }\n\n    else\n        this._handlePlainObject(val);\n};\n\nDecodingTransformer.prototype.transform = function () {\n    this.visitedRefs[0] = true;\n    this._handleValue(this.references[0], this.references, 0);\n\n    return this.references[0];\n};\n\n// Transforms\nvar builtInTransforms = [\n    {\n        type: '[[NaN]]',\n\n        shouldTransform: function (type, val) {\n            return type === 'number' && isNaN(val);\n        },\n\n        toSerializable: function () {\n            return '';\n        },\n\n        fromSerializable: function () {\n            return NaN;\n        },\n    },\n\n    {\n        type: '[[undefined]]',\n\n        shouldTransform: function (type) {\n            return type === 'undefined';\n        },\n\n        toSerializable: function () {\n            return '';\n        },\n\n        fromSerializable: function () {\n            return void 0;\n        },\n    },\n\n    {\n        type: '[[Date]]',\n\n        shouldTransform: function (type, val) {\n            return val instanceof Date;\n        },\n\n        toSerializable: function (date) {\n            return date.getTime();\n        },\n\n        fromSerializable: function (val) {\n            var date = new Date();\n\n            date.setTime(val);\n\n            return date;\n        },\n    },\n\n    {\n        type: '[[RegExp]]',\n\n        shouldTransform: function (type, val) {\n            return val instanceof RegExp;\n        },\n\n        toSerializable: function (re) {\n            var result = {\n                src:   re.source,\n                flags: '',\n            };\n\n            if (re.global)\n                result.flags += 'g';\n\n            if (re.ignoreCase)\n                result.flags += 'i';\n\n            if (re.multiline)\n                result.flags += 'm';\n\n            return result;\n        },\n\n        fromSerializable: function (val) {\n            return new RegExp(val.src, val.flags);\n        },\n    },\n\n    {\n        type: '[[Error]]',\n\n        shouldTransform: function (type, val) {\n            return val instanceof Error;\n        },\n\n        toSerializable: function (err) {\n            return {\n                name:    err.name,\n                message: err.message,\n                stack:   err.stack,\n            };\n        },\n\n        fromSerializable: function (val) {\n            var Ctor = SAFE_ERROR_CTORS[val.name] || Error;\n            var err  = new Ctor(val.message);\n\n            err.stack = val.stack;\n\n            return err;\n        },\n    },\n\n    {\n        type: '[[ArrayBuffer]]',\n\n        shouldTransform: function (type, val) {\n            return ARRAY_BUFFER_SUPPORTED && val instanceof ArrayBuffer;\n        },\n\n        toSerializable: function (buffer) {\n            var view = new Int8Array(buffer);\n\n            return arrSlice.call(view);\n        },\n\n        fromSerializable: function (val) {\n            if (ARRAY_BUFFER_SUPPORTED) {\n                var buffer = new ArrayBuffer(val.length);\n                var view   = new Int8Array(buffer);\n\n                view.set(val);\n\n                return buffer;\n            }\n\n            return val;\n        },\n    },\n\n    {\n        type: '[[Buffer]]',\n\n        shouldTransform: function (type, val) {\n            return BUFFER_FROM_SUPPORTED && val instanceof Buffer;\n        },\n\n        toSerializable: function (buffer) {\n            return arrSlice.call(buffer);\n        },\n\n        fromSerializable: function (val) {\n            if (BUFFER_FROM_SUPPORTED)\n                return Buffer.from(val);\n\n            return val;\n        },\n    },\n\n    {\n        type: '[[TypedArray]]',\n\n        shouldTransform: function (type, val) {\n            return Object.keys(TYPED_ARRAY_CTORS).some(ctorName => {\n                return TYPED_ARRAY_SUPPORTED(ctorName) && val instanceof TYPED_ARRAY_CTORS[ctorName];\n            });\n        },\n\n        toSerializable: function (arr) {\n            return {\n                ctorName: arr.constructor.name,\n                arr:      arrSlice.call(arr),\n            };\n        },\n\n        fromSerializable: function (val) {\n            return TYPED_ARRAY_SUPPORTED(val.ctorName) ? new TYPED_ARRAY_CTORS[val.ctorName](val.arr) : val.arr;\n        },\n    },\n\n    {\n        type: '[[Map]]',\n\n        shouldTransform: function (type, val) {\n            return MAP_SUPPORTED && val instanceof Map;\n        },\n\n        toSerializable: function (map) {\n            var flattenedKVArr = [];\n\n            map.forEach((val, key) => {\n                flattenedKVArr.push(key);\n                flattenedKVArr.push(val);\n            });\n\n            return flattenedKVArr;\n        },\n\n        fromSerializable: function (val) {\n            if (MAP_SUPPORTED) {\n                // NOTE: new Map(iterable) is not supported by all browsers\n                var map = new Map();\n\n                for (var i = 0; i < val.length; i += 2)\n                    map.set(val[i], val[i + 1]);\n\n                return map;\n            }\n\n            var kvArr = [];\n\n            for (var j = 0; j < val.length; j += 2)\n                kvArr.push([val[j], val[j + 1]]);\n\n            return kvArr;\n        },\n    },\n\n    {\n        type: '[[Set]]',\n\n        shouldTransform: function (type, val) {\n            return SET_SUPPORTED && val instanceof Set;\n        },\n\n        toSerializable: function (set) {\n            var arr = [];\n\n            set.forEach(val => {\n                arr.push(val);\n            });\n\n            return arr;\n        },\n\n        fromSerializable: function (val) {\n            if (SET_SUPPORTED) {\n                // NOTE: new Set(iterable) is not supported by all browsers\n                var set = new Set();\n\n                for (var i = 0; i < val.length; i++)\n                    set.add(val[i]);\n\n                return set;\n            }\n\n            return val;\n        },\n    },\n];\n\n// Replicator\nvar Replicator = function (serializer) {\n    this.transforms    = [];\n    this.transformsMap = Object.create(null);\n    this.serializer    = serializer || JSONSerializer;\n\n    this.addTransforms(builtInTransforms);\n};\n\n// Manage transforms\nReplicator.prototype.addTransforms = function (transforms) {\n    transforms = Array.isArray(transforms) ? transforms : [transforms];\n\n    for (var i = 0; i < transforms.length; i++) {\n        var transform = transforms[i];\n\n        if (this.transformsMap[transform.type])\n            throw new Error('Transform with type \"' + transform.type + '\" was already added.');\n\n        this.transforms.push(transform);\n        this.transformsMap[transform.type] = transform;\n    }\n\n    return this;\n};\n\nReplicator.prototype.removeTransforms = function (transforms) {\n    transforms = Array.isArray(transforms) ? transforms : [transforms];\n\n    for (var i = 0; i < transforms.length; i++) {\n        var transform = transforms[i];\n        var idx       = this.transforms.indexOf(transform);\n\n        if (idx > -1)\n            this.transforms.splice(idx, 1);\n\n        delete this.transformsMap[transform.type];\n    }\n\n    return this;\n};\n\nReplicator.prototype.encode = function (val) {\n    var transformer = new EncodingTransformer(val, this.transforms);\n    var references  = transformer.transform();\n\n    return this.serializer.serialize(references);\n};\n\nReplicator.prototype.decode = function (val) {\n    var references  = this.serializer.deserialize(val);\n    var transformer = new DecodingTransformer(references, this.transformsMap);\n\n    return transformer.transform();\n};\n\nexport default Replicator;\n"]}

package/package.json

@@ -2,7 +2,7 @@
   "name": "testcafe",
   "description": "Automated browser testing for the modern web development stack.",
   "license": "MIT",
-  "version": "3.7.4",
+  "version": "3.7.5",
   "author": {
     "name": "Developer Express Inc.",
     "url": "https://www.devexpress.com/"
@@ -19,7 +19,7 @@
     "url": "git+https://github.com/DevExpress/testcafe.git"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "main": "lib/index",
   "types": "ts-defs/index.d.ts",
@@ -55,10 +55,7 @@
     "test": "gulp travis",
     "build": "gulp build",
     "test-functional-local-headless-chrome-run-esm": "cross-env NODE_OPTIONS='--experimental-loader=./lib/compiler/esm-loader.js' gulp test-functional-local-headless-chrome-run --steps-as-tasks",
-    "test-functional-local-headless-chrome-esm": "npm run build && npm run test-functional-local-headless-chrome-run-esm",
-    "publish-please-only": "publish-please",
-    "publish-please": "del-cli package-lock.json node_modules && npm i && publish-please",
-    "prepublishOnly": "publish-please guard"
+    "test-functional-local-headless-chrome-esm": "npm run build && npm run test-functional-local-headless-chrome-run-esm"
   },
   "dependencies": {
     "@babel/core": "^7.23.2",
@@ -74,7 +71,7 @@
     "@babel/plugin-transform-object-rest-spread": "^7.24.7",
     "@babel/plugin-transform-private-methods": "^7.25.4",
     "@babel/plugin-transform-runtime": "7.23.3",
-    "@babel/preset-env": "^7.23.2",
+    "@babel/preset-env": "^7.29.5",
     "@babel/preset-flow": "^7.22.15",
     "@babel/preset-react": "^7.22.15",
     "@babel/runtime": "^7.23.2",
@@ -135,7 +132,6 @@
     "prompts": "^2.4.2",
     "qrcode-terminal": "^0.10.0",
     "read-file-relative": "^1.2.0",
-    "replicator": "^1.0.5",
     "resolve-cwd": "^1.0.0",
     "resolve-from": "^4.0.0",
     "sanitize-filename": "^1.6.0",
@@ -144,7 +140,7 @@
     "source-map-support": "^0.5.16",
     "strip-bom": "^2.0.0",
     "testcafe-browser-tools": "2.0.26",
-    "testcafe-hammerhead": "31.7.7",
+    "testcafe-hammerhead": "31.7.8",
     "testcafe-legacy-api": "5.1.8",
     "testcafe-reporter-json": "^2.1.0",
     "testcafe-reporter-list": "^2.2.0",
@@ -153,9 +149,9 @@
     "testcafe-reporter-xunit": "^2.2.1",
     "testcafe-selector-generator": "^0.1.0",
     "time-limit-promise": "^1.0.2",
-    "tmp": "0.2.5",
+    "tmp": "0.2.6",
     "tree-kill": "^1.2.2",
-    "typescript": "4.7.4",
+    "typescript": "4.9.5",
     "unquote": "^1.1.1",
     "url-to-options": "^2.0.0"
   },
@@ -167,7 +163,6 @@
     "@rollup/plugin-commonjs": "^11.0.2",
     "@rollup/plugin-inject": "^4.0.2",
     "@rollup/plugin-node-resolve": "^7.1.1",
-    "@testcafe/publish-please": "^5.6.0",
     "@types/callsite": "^1.0.30",
     "@types/chai": "^3.5.2",
     "@types/debug": "^4.1.5",
@@ -181,8 +176,8 @@
     "@types/set-cookie-parser": "^2.4.2",
     "@types/source-map-support": "^0.5.0",
     "@types/useragent": "^2.1.1",
-    "@typescript-eslint/eslint-plugin": "^5.29.0",
-    "@typescript-eslint/parser": "^5.29.0",
+    "@typescript-eslint/eslint-plugin": "^8.59.2",
+    "@typescript-eslint/parser": "^8.59.2",
     "babel-plugin-add-module-exports": "^0.2.0",
     "basic-auth": "^1.1.0",
     "body-parser": "^1.17.1",
@@ -196,34 +191,32 @@
     "cross-env": "^7.0.3",
     "dom-walk": "^0.1.1",
     "escape-string-regexp": "^4.0.0",
-    "eslint": "^7.13.0",
+    "eslint": "^9.39.4",
     "eslint-plugin-hammerhead": "0.4.0",
     "eslint-plugin-no-only-tests": "^2.0.1",
     "express": "^4.13.3",
     "express-ntlm": "2.4.0",
-    "gulp": "^4.0.2",
+    "gulp": "^5.0.1",
     "gulp-babel": "^8.0.0",
     "gulp-clone": "^2.0.1",
     "gulp-data": "^1.3.1",
-    "gulp-eslint": "^6.0.0",
+    "gulp-eslint-new": "^2.6.2",
     "gulp-less": "^5.0.0",
     "gulp-ll-next": "^2.1.0",
-    "gulp-mocha-simple": "^2.0.0",
     "gulp-mustache": "^3.0.1",
     "gulp-rename": "^1.3.0",
     "gulp-step": "^1.0.1",
     "gulp-uglify": "^3.0.0",
     "license-checker": "^20.0.0",
-    "markdownlint": "^0.34.0",
     "merge-stream": "^1.0.1",
     "minimist": "^1.2.0",
-    "mocha-reporter-spec-with-retries": "1.0.0",
-    "multer": "2.0.2",
+    "mocha": "^11.7.5",
+    "multer": "^2.1.1",
     "openssl-self-signed-certificate": "^1.1.6",
     "proxyquire": "^2.1.0",
     "react": "^16.13.1",
     "recursive-copy": "^2.0.5",
-    "rollup": "2.79.2",
+    "rollup": "^2.80.0",
     "rollup-plugin-typescript2": "^0.32.1",
     "serve-static": "^1.10.0",
     "sinon": "^7.3.0",
@@ -234,6 +227,10 @@
     "uglify-js": "~3.10.4"
   },
   "overrides": {
-    "glob": "8.1.0"
+    "glob": "8.1.0",
+    "mocha": {
+      "serialize-javascript": "^7.0.5",
+      "diff": "^8.0.0"
+    }
   }
 }