@bigbinary/neeto-playwright-commons 1.26.6 → 1.26.8

package/index.cjs.js

@@ -3593,10 +3593,32 @@ function requireUtils$4 () {
 	hasRequiredUtils$4 = 1;
 
 	var formats = /*@__PURE__*/ requireFormats();
+	var getSideChannel = requireSideChannel();
 
 	var has = Object.prototype.hasOwnProperty;
 	var isArray = Array.isArray;
 
+	// Track objects created from arrayLimit overflow using side-channel
+	// Stores the current max numeric index for O(1) lookup
+	var overflowChannel = getSideChannel();
+
+	var markOverflow = function markOverflow(obj, maxIndex) {
+	    overflowChannel.set(obj, maxIndex);
+	    return obj;
+	};
+
+	var isOverflow = function isOverflow(obj) {
+	    return overflowChannel.has(obj);
+	};
+
+	var getMaxIndex = function getMaxIndex(obj) {
+	    return overflowChannel.get(obj);
+	};
+
+	var setMaxIndex = function setMaxIndex(obj, maxIndex) {
+	    overflowChannel.set(obj, maxIndex);
+	};
+
 	var hexTable = (function () {
 	    var array = [];
 	    for (var i = 0; i < 256; ++i) {
@@ -3646,7 +3668,12 @@ function requireUtils$4 () {
 	        if (isArray(target)) {
 	            target.push(source);
 	        } else if (target && typeof target === 'object') {
-	            if (
+	            if (isOverflow(target)) {
+	                // Add at next numeric index for overflow objects
+	                var newIndex = getMaxIndex(target) + 1;
+	                target[newIndex] = source;
+	                setMaxIndex(target, newIndex);
+	            } else if (
 	                (options && (options.plainObjects || options.allowPrototypes))
 	                || !has.call(Object.prototype, source)
 	            ) {
@@ -3660,6 +3687,18 @@ function requireUtils$4 () {
 	    }
 
 	    if (!target || typeof target !== 'object') {
+	        if (isOverflow(source)) {
+	            // Create new object with target at 0, source values shifted by 1
+	            var sourceKeys = Object.keys(source);
+	            var result = options && options.plainObjects
+	                ? { __proto__: null, 0: target }
+	                : { 0: target };
+	            for (var m = 0; m < sourceKeys.length; m++) {
+	                var oldKey = parseInt(sourceKeys[m], 10);
+	                result[oldKey + 1] = source[sourceKeys[m]];
+	            }
+	            return markOverflow(result, getMaxIndex(source) + 1);
+	        }
 	        return [target].concat(source);
 	    }
 
@@ -3831,8 +3870,20 @@ function requireUtils$4 () {
 	    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
 	};
 
-	var combine = function combine(a, b) {
-	    return [].concat(a, b);
+	var combine = function combine(a, b, arrayLimit, plainObjects) {
+	    // If 'a' is already an overflow object, add to it
+	    if (isOverflow(a)) {
+	        var newIndex = getMaxIndex(a) + 1;
+	        a[newIndex] = b;
+	        setMaxIndex(a, newIndex);
+	        return a;
+	    }
+
+	    var result = [].concat(a, b);
+	    if (result.length > arrayLimit) {
+	        return markOverflow(arrayToObject(result, { plainObjects: plainObjects }), result.length - 1);
+	    }
+	    return result;
 	};
 
 	var maybeMap = function maybeMap(val, fn) {
@@ -3854,6 +3905,7 @@ function requireUtils$4 () {
 	    decode: decode,
 	    encode: encode,
 	    isBuffer: isBuffer,
+	    isOverflow: isOverflow,
 	    isRegExp: isRegExp,
 	    maybeMap: maybeMap,
 	    merge: merge
@@ -4340,16 +4392,18 @@ function requireParse$4 () {
 	        } else {
 	            key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
 
-	            val = utils.maybeMap(
-	                parseArrayValue(
-	                    part.slice(pos + 1),
-	                    options,
-	                    isArray(obj[key]) ? obj[key].length : 0
-	                ),
-	                function (encodedVal) {
-	                    return options.decoder(encodedVal, defaults.decoder, charset, 'value');
-	                }
-	            );
+	            if (key !== null) {
+	                val = utils.maybeMap(
+	                    parseArrayValue(
+	                        part.slice(pos + 1),
+	                        options,
+	                        isArray(obj[key]) ? obj[key].length : 0
+	                    ),
+	                    function (encodedVal) {
+	                        return options.decoder(encodedVal, defaults.decoder, charset, 'value');
+	                    }
+	                );
+	            }
 	        }
 
 	        if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
@@ -4360,11 +4414,18 @@ function requireParse$4 () {
 	            val = isArray(val) ? [val] : val;
 	        }
 
-	        var existing = has.call(obj, key);
-	        if (existing && options.duplicates === 'combine') {
-	            obj[key] = utils.combine(obj[key], val);
-	        } else if (!existing || options.duplicates === 'last') {
-	            obj[key] = val;
+	        if (key !== null) {
+	            var existing = has.call(obj, key);
+	            if (existing && options.duplicates === 'combine') {
+	                obj[key] = utils.combine(
+	                    obj[key],
+	                    val,
+	                    options.arrayLimit,
+	                    options.plainObjects
+	                );
+	            } else if (!existing || options.duplicates === 'last') {
+	                obj[key] = val;
+	            }
 	        }
 	    }
 
@@ -4385,9 +4446,19 @@ function requireParse$4 () {
 	        var root = chain[i];
 
 	        if (root === '[]' && options.parseArrays) {
-	            obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
-	                ? []
-	                : utils.combine([], leaf);
+	            if (utils.isOverflow(leaf)) {
+	                // leaf is already an overflow object, preserve it
+	                obj = leaf;
+	            } else {
+	                obj = options.allowEmptyArrays && (leaf === '' || (options.strictNullHandling && leaf === null))
+	                    ? []
+	                    : utils.combine(
+	                        [],
+	                        leaf,
+	                        options.arrayLimit,
+	                        options.plainObjects
+	                    );
+	            }
 	        } else {
 	            obj = options.plainObjects ? { __proto__: null } : {};
 	            var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
@@ -4415,29 +4486,28 @@ function requireParse$4 () {
 	    return leaf;
 	};
 
-	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
-	    if (!givenKey) {
-	        return;
-	    }
-
-	    // Transform dot notation to bracket notation
+	var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
 	    var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
 
-	    // The regex chunks
+	    if (options.depth <= 0) {
+	        if (!options.plainObjects && has.call(Object.prototype, key)) {
+	            if (!options.allowPrototypes) {
+	                return;
+	            }
+	        }
+
+	        return [key];
+	    }
 
 	    var brackets = /(\[[^[\]]*])/;
 	    var child = /(\[[^[\]]*])/g;
 
-	    // Get the parent
-
-	    var segment = options.depth > 0 && brackets.exec(key);
+	    var segment = brackets.exec(key);
 	    var parent = segment ? key.slice(0, segment.index) : key;
 
-	    // Stash the parent if it exists
-
 	    var keys = [];
+
 	    if (parent) {
-	        // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
 	        if (!options.plainObjects && has.call(Object.prototype, parent)) {
 	            if (!options.allowPrototypes) {
 	                return;
@@ -4447,28 +4517,42 @@ function requireParse$4 () {
 	        keys.push(parent);
 	    }
 
-	    // Loop through children appending to the array until we hit depth
-
 	    var i = 0;
-	    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
+	    while ((segment = child.exec(key)) !== null && i < options.depth) {
 	        i += 1;
-	        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
+
+	        var segmentContent = segment[1].slice(1, -1);
+	        if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
 	            if (!options.allowPrototypes) {
 	                return;
 	            }
 	        }
+
 	        keys.push(segment[1]);
 	    }
 
-	    // If there's a remainder, check strictDepth option for throw, else just add whatever is left
-
 	    if (segment) {
 	        if (options.strictDepth === true) {
 	            throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
 	        }
+
 	        keys.push('[' + key.slice(segment.index) + ']');
 	    }
 
+	    return keys;
+	};
+
+	var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+	    if (!givenKey) {
+	        return;
+	    }
+
+	    var keys = splitKeyIntoSegments(givenKey, options);
+
+	    if (!keys) {
+	        return;
+	    }
+
 	    return parseObject(keys, val, options, valuesParsed);
 	};
 
@@ -117319,6 +117403,13 @@ class SlashCommandEditorPage {
             return [{ key: "image-upload", value: imagePath }];
         };
         this.verifyDividerModifier = () => test.expect(this.contentField.locator("hr")).toBeVisible();
+        this.verifyTodoListSelector = async () => {
+            const randomText = await this.fillRandomText();
+            await test.expect(this.contentField.locator(NEETO_EDITOR_SELECTORS.todoList, {
+                hasText: randomText,
+            })).toBeVisible();
+            return [{ key: "todoList", value: randomText }];
+        };
         this.slashCommandsAndVerifications = {
             normalText: () => this.verifyFontSize("normal"),
             heading1: () => this.verifyFontSize(1),
@@ -117337,6 +117428,7 @@ class SlashCommandEditorPage {
             image: () => this.verifyImageUploadOption(this.filePath),
             emoji: () => this.verifyEmojiSelector(),
             divider: () => this.verifyDividerModifier(),
+            "to-doList": () => this.verifyTodoListSelector(),
         };
         this.getRandomText = () => {
             let randomText;