patchright-core 1.51.2 → 1.52.0

package/lib/utils/isomorphic/semaphore.js

@@ -1,29 +1,29 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var semaphore_exports = {};
+__export(semaphore_exports, {
+  Semaphore: () => Semaphore
 });
-exports.Semaphore = void 0;
-var _manualPromise = require("./manualPromise");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
+module.exports = __toCommonJS(semaphore_exports);
+var import_manualPromise = require("./manualPromise");
 class Semaphore {
   constructor(max) {
-    this._max = void 0;
     this._acquired = 0;
     this._queue = [];
     this._max = max;
@@ -32,7 +32,7 @@ class Semaphore {
     this._max = max;
   }
   acquire() {
-    const lock = new _manualPromise.ManualPromise();
+    const lock = new import_manualPromise.ManualPromise();
     this._queue.push(lock);
     this._flush();
     return lock;
@@ -48,4 +48,7 @@ class Semaphore {
     }
   }
 }
-exports.Semaphore = Semaphore;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Semaphore
+});

package/lib/utils/isomorphic/stackTrace.js

@@ -1,73 +1,69 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stackTrace_exports = {};
+__export(stackTrace_exports, {
+  captureRawStack: () => captureRawStack,
+  parseErrorStack: () => parseErrorStack,
+  parseStackFrame: () => parseStackFrame,
+  rewriteErrorMessage: () => rewriteErrorMessage,
+  splitErrorMessage: () => splitErrorMessage,
+  stringifyStackFrames: () => stringifyStackFrames
 });
-exports.captureRawStack = captureRawStack;
-exports.parseErrorStack = parseErrorStack;
-exports.parseStackFrame = parseStackFrame;
-exports.rewriteErrorMessage = rewriteErrorMessage;
-exports.splitErrorMessage = splitErrorMessage;
-exports.stringifyStackFrames = stringifyStackFrames;
-/**
- * The MIT License (MIT)
- * Modifications copyright (c) Microsoft Corporation.
- *
- * Copyright (c) 2016-2023 Isaac Z. Schlueter i@izs.me, James Talmage james@talmage.io (github.com/jamestalmage), and
- * Contributors
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
+module.exports = __toCommonJS(stackTrace_exports);
 function captureRawStack() {
   const stackTraceLimit = Error.stackTraceLimit;
   Error.stackTraceLimit = 50;
   const error = new Error();
-  const stack = error.stack || '';
+  const stack = error.stack || "";
   Error.stackTraceLimit = stackTraceLimit;
-  return stack.split('\n');
+  return stack.split("\n");
 }
 function parseStackFrame(text, pathSeparator, showInternalStackFrames) {
   const match = text && text.match(re);
-  if (!match) return null;
+  if (!match)
+    return null;
   let fname = match[2];
   let file = match[7];
-  if (!file) return null;
-  if (!showInternalStackFrames && (file.startsWith('internal') || file.startsWith('node:'))) return null;
+  if (!file)
+    return null;
+  if (!showInternalStackFrames && (file.startsWith("internal") || file.startsWith("node:")))
+    return null;
   const line = match[8];
   const column = match[9];
-  const closeParen = match[11] === ')';
+  const closeParen = match[11] === ")";
   const frame = {
-    file: '',
+    file: "",
     line: 0,
     column: 0
   };
-  if (line) frame.line = Number(line);
-  if (column) frame.column = Number(column);
+  if (line)
+    frame.line = Number(line);
+  if (column)
+    frame.column = Number(column);
   if (closeParen && file) {
-    // make sure parens are balanced
-    // if we have a file like "asdf) [as foo] (xyz.js", then odds are
-    // that the fname should be += " (asdf) [as foo]" and the file
-    // should be just "xyz.js"
-    // walk backwards from the end to find the last unbalanced (
     let closes = 0;
     for (let i = file.length - 1; i > 0; i--) {
-      if (file.charAt(i) === ')') {
+      if (file.charAt(i) === ")") {
         closes++;
-      } else if (file.charAt(i) === '(' && file.charAt(i - 1) === ' ') {
+      } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
         closes--;
-        if (closes === -1 && file.charAt(i - 1) === ' ') {
+        if (closes === -1 && file.charAt(i - 1) === " ") {
           const before = file.slice(0, i - 1);
           const after = file.slice(i + 1);
           file = after;
@@ -79,91 +75,84 @@ function parseStackFrame(text, pathSeparator, showInternalStackFrames) {
   }
   if (fname) {
     const methodMatch = fname.match(methodRe);
-    if (methodMatch) fname = methodMatch[1];
+    if (methodMatch)
+      fname = methodMatch[1];
   }
   if (file) {
-    if (file.startsWith('file://')) file = fileURLToPath(file, pathSeparator);
+    if (file.startsWith("file://"))
+      file = fileURLToPath(file, pathSeparator);
     frame.file = file;
   }
-  if (fname) frame.function = fname;
+  if (fname)
+    frame.function = fname;
   return frame;
 }
 function rewriteErrorMessage(e, newMessage) {
-  var _e$stack;
-  const lines = (((_e$stack = e.stack) === null || _e$stack === void 0 ? void 0 : _e$stack.split('\n')) || []).filter(l => l.startsWith('    at '));
+  const lines = (e.stack?.split("\n") || []).filter((l) => l.startsWith("    at "));
   e.message = newMessage;
   const errorTitle = `${e.name}: ${e.message}`;
-  if (lines.length) e.stack = `${errorTitle}\n${lines.join('\n')}`;
+  if (lines.length)
+    e.stack = `${errorTitle}
+${lines.join("\n")}`;
   return e;
 }
 function stringifyStackFrames(frames) {
   const stackLines = [];
   for (const frame of frames) {
-    if (frame.function) stackLines.push(`    at ${frame.function} (${frame.file}:${frame.line}:${frame.column})`);else stackLines.push(`    at ${frame.file}:${frame.line}:${frame.column}`);
+    if (frame.function)
+      stackLines.push(`    at ${frame.function} (${frame.file}:${frame.line}:${frame.column})`);
+    else
+      stackLines.push(`    at ${frame.file}:${frame.line}:${frame.column}`);
   }
   return stackLines;
 }
 function splitErrorMessage(message) {
-  const separationIdx = message.indexOf(':');
+  const separationIdx = message.indexOf(":");
   return {
-    name: separationIdx !== -1 ? message.slice(0, separationIdx) : '',
+    name: separationIdx !== -1 ? message.slice(0, separationIdx) : "",
     message: separationIdx !== -1 && separationIdx + 2 <= message.length ? message.substring(separationIdx + 2) : message
   };
 }
 function parseErrorStack(stack, pathSeparator, showInternalStackFrames = false) {
-  const lines = stack.split('\n');
-  let firstStackLine = lines.findIndex(line => line.startsWith('    at '));
-  if (firstStackLine === -1) firstStackLine = lines.length;
-  const message = lines.slice(0, firstStackLine).join('\n');
+  const lines = stack.split("\n");
+  let firstStackLine = lines.findIndex((line) => line.startsWith("    at "));
+  if (firstStackLine === -1)
+    firstStackLine = lines.length;
+  const message = lines.slice(0, firstStackLine).join("\n");
   const stackLines = lines.slice(firstStackLine);
   let location;
   for (const line of stackLines) {
     const frame = parseStackFrame(line, pathSeparator, showInternalStackFrames);
-    if (!frame || !frame.file) continue;
-    if (belongsToNodeModules(frame.file, pathSeparator)) continue;
-    location = {
-      file: frame.file,
-      column: frame.column || 0,
-      line: frame.line || 0
-    };
+    if (!frame || !frame.file)
+      continue;
+    if (belongsToNodeModules(frame.file, pathSeparator))
+      continue;
+    location = { file: frame.file, column: frame.column || 0, line: frame.line || 0 };
     break;
   }
-  return {
-    message,
-    stackLines,
-    location
-  };
+  return { message, stackLines, location };
 }
 function belongsToNodeModules(file, pathSeparator) {
   return file.includes(`${pathSeparator}node_modules${pathSeparator}`);
 }
-const re = new RegExp('^' +
-// Sometimes we strip out the '    at' because it's noisy
-'(?:\\s*at )?' +
-// $1 = ctor if 'new'
-'(?:(new) )?' +
-// $2 = function name (can be literally anything)
-// May contain method at the end as [as xyz]
-'(?:(.*?) \\()?' +
-// (eval at <anonymous> (file.js:1:1),
-// $3 = eval origin
-// $4:$5:$6 are eval file/line/col, but not normally reported
-'(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?' +
-// file:line:col
-// $7:$8:$9
-// $10 = 'native' if native
-'(?:(.+?):(\\d+):(\\d+)|(native))' +
-// maybe close the paren, then end
-// if $11 is ), then we only allow balanced parens in the filename
-// any imbalance is placed on the fname.  This is a heuristic, and
-// bound to be incorrect in some edge cases.  The bet is that
-// having weird characters in method names is more common than
-// having weird characters in filenames, which seems reasonable.
-'(\\)?)$');
+const re = new RegExp(
+  "^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$"
+);
 const methodRe = /^(.*?) \[as (.*?)\]$/;
 function fileURLToPath(fileUrl, pathSeparator) {
-  if (!fileUrl.startsWith('file://')) return fileUrl;
+  if (!fileUrl.startsWith("file://"))
+    return fileUrl;
   let path = decodeURIComponent(fileUrl.slice(7));
-  if (path.startsWith('/') && /^[a-zA-Z]:/.test(path.slice(1))) path = path.slice(1);
+  if (path.startsWith("/") && /^[a-zA-Z]:/.test(path.slice(1)))
+    path = path.slice(1);
   return path.replace(/\//g, pathSeparator);
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureRawStack,
+  parseErrorStack,
+  parseStackFrame,
+  rewriteErrorMessage,
+  splitErrorMessage,
+  stringifyStackFrames
+});

package/lib/utils/isomorphic/stringUtils.js

@@ -1,157 +1,145 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stringUtils_exports = {};
+__export(stringUtils_exports, {
+  cacheNormalizedWhitespaces: () => cacheNormalizedWhitespaces,
+  cssEscape: () => cssEscape,
+  escapeForAttributeSelector: () => escapeForAttributeSelector,
+  escapeForTextSelector: () => escapeForTextSelector,
+  escapeHTML: () => escapeHTML,
+  escapeHTMLAttribute: () => escapeHTMLAttribute,
+  escapeRegExp: () => escapeRegExp,
+  escapeTemplateString: () => escapeTemplateString,
+  escapeWithQuotes: () => escapeWithQuotes,
+  isString: () => isString,
+  longestCommonSubstring: () => longestCommonSubstring,
+  normalizeEscapedRegexQuotes: () => normalizeEscapedRegexQuotes,
+  normalizeWhiteSpace: () => normalizeWhiteSpace,
+  quoteCSSAttributeValue: () => quoteCSSAttributeValue,
+  toSnakeCase: () => toSnakeCase,
+  toTitleCase: () => toTitleCase,
+  trimString: () => trimString,
+  trimStringWithEllipsis: () => trimStringWithEllipsis
 });
-exports.cacheNormalizedWhitespaces = cacheNormalizedWhitespaces;
-exports.cssEscape = cssEscape;
-exports.escapeForAttributeSelector = escapeForAttributeSelector;
-exports.escapeForTextSelector = escapeForTextSelector;
-exports.escapeHTML = escapeHTML;
-exports.escapeHTMLAttribute = escapeHTMLAttribute;
-exports.escapeRegExp = escapeRegExp;
-exports.escapeTemplateString = escapeTemplateString;
-exports.escapeWithQuotes = escapeWithQuotes;
-exports.isString = isString;
-exports.longestCommonSubstring = longestCommonSubstring;
-exports.normalizeEscapedRegexQuotes = normalizeEscapedRegexQuotes;
-exports.normalizeWhiteSpace = normalizeWhiteSpace;
-exports.quoteCSSAttributeValue = quoteCSSAttributeValue;
-exports.toSnakeCase = toSnakeCase;
-exports.toTitleCase = toTitleCase;
-exports.trimString = trimString;
-exports.trimStringWithEllipsis = trimStringWithEllipsis;
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// NOTE: this function should not be used to escape any selectors.
-function escapeWithQuotes(text, char = '\'') {
+module.exports = __toCommonJS(stringUtils_exports);
+var import_builtins = require("./builtins");
+function escapeWithQuotes(text, char = "'") {
   const stringified = JSON.stringify(text);
   const escapedText = stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
-  if (char === '\'') return char + escapedText.replace(/[']/g, '\\\'') + char;
-  if (char === '"') return char + escapedText.replace(/["]/g, '\\"') + char;
-  if (char === '`') return char + escapedText.replace(/[`]/g, '`') + char;
-  throw new Error('Invalid escape char');
+  if (char === "'")
+    return char + escapedText.replace(/[']/g, "\\'") + char;
+  if (char === '"')
+    return char + escapedText.replace(/["]/g, '\\"') + char;
+  if (char === "`")
+    return char + escapedText.replace(/[`]/g, "`") + char;
+  throw new Error("Invalid escape char");
 }
 function escapeTemplateString(text) {
-  return text.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
 }
 function isString(obj) {
-  return typeof obj === 'string' || obj instanceof String;
+  return typeof obj === "string" || obj instanceof String;
 }
 function toTitleCase(name) {
   return name.charAt(0).toUpperCase() + name.substring(1);
 }
 function toSnakeCase(name) {
-  // E.g. ignoreHTTPSErrors => ignore_https_errors.
-  return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/([A-Z])([A-Z][a-z])/g, '$1_$2').toLowerCase();
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
 }
 function cssEscape(s) {
-  let result = '';
-  for (let i = 0; i < s.length; i++) result += cssEscapeOne(s, i);
+  let result = "";
+  for (let i = 0; i < s.length; i++)
+    result += cssEscapeOne(s, i);
   return result;
 }
 function quoteCSSAttributeValue(text) {
-  return `"${cssEscape(text).replace(/\\ /g, ' ')}"`;
+  return `"${cssEscape(text).replace(/\\ /g, " ")}"`;
 }
 function cssEscapeOne(s, i) {
-  // https://drafts.csswg.org/cssom/#serialize-an-identifier
   const c = s.charCodeAt(i);
-  if (c === 0x0000) return '\uFFFD';
-  if (c >= 0x0001 && c <= 0x001f || c >= 0x0030 && c <= 0x0039 && (i === 0 || i === 1 && s.charCodeAt(0) === 0x002d)) return '\\' + c.toString(16) + ' ';
-  if (i === 0 && c === 0x002d && s.length === 1) return '\\' + s.charAt(i);
-  if (c >= 0x0080 || c === 0x002d || c === 0x005f || c >= 0x0030 && c <= 0x0039 || c >= 0x0041 && c <= 0x005a || c >= 0x0061 && c <= 0x007a) return s.charAt(i);
-  return '\\' + s.charAt(i);
+  if (c === 0)
+    return "\uFFFD";
+  if (c >= 1 && c <= 31 || c >= 48 && c <= 57 && (i === 0 || i === 1 && s.charCodeAt(0) === 45))
+    return "\\" + c.toString(16) + " ";
+  if (i === 0 && c === 45 && s.length === 1)
+    return "\\" + s.charAt(i);
+  if (c >= 128 || c === 45 || c === 95 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122)
+    return s.charAt(i);
+  return "\\" + s.charAt(i);
 }
 let normalizedWhitespaceCache;
 function cacheNormalizedWhitespaces() {
-  normalizedWhitespaceCache = new Map();
+  normalizedWhitespaceCache = new import_builtins.Map();
 }
 function normalizeWhiteSpace(text) {
-  var _normalizedWhitespace;
-  let result = (_normalizedWhitespace = normalizedWhitespaceCache) === null || _normalizedWhitespace === void 0 ? void 0 : _normalizedWhitespace.get(text);
-  if (result === undefined) {
-    var _normalizedWhitespace2;
-    result = text.replace(/[\u200b\u00ad]/g, '').trim().replace(/\s+/g, ' ');
-    (_normalizedWhitespace2 = normalizedWhitespaceCache) === null || _normalizedWhitespace2 === void 0 || _normalizedWhitespace2.set(text, result);
+  let result = normalizedWhitespaceCache?.get(text);
+  if (result === void 0) {
+    result = text.replace(/[\u200b\u00ad]/g, "").trim().replace(/\s+/g, " ");
+    normalizedWhitespaceCache?.set(text, result);
   }
   return result;
 }
 function normalizeEscapedRegexQuotes(source) {
-  // This function reverses the effect of escapeRegexForSelector below.
-  // Odd number of backslashes followed by the quote -> remove unneeded backslash.
-  return source.replace(/(^|[^\\])(\\\\)*\\(['"`])/g, '$1$2$3');
+  return source.replace(/(^|[^\\])(\\\\)*\\(['"`])/g, "$1$2$3");
 }
 function escapeRegexForSelector(re) {
-  // Unicode mode does not allow "identity character escapes", so we do not escape and
-  // hope that it does not contain quotes and/or >> signs.
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Character_escape
-  // TODO: rework RE usages in internal selectors away from literal representation to json, e.g. {source,flags}.
-  if (re.unicode || re.unicodeSets) return String(re);
-  // Even number of backslashes followed by the quote -> insert a backslash.
-  return String(re).replace(/(^|[^\\])(\\\\)*(["'`])/g, '$1$2\\$3').replace(/>>/g, '\\>\\>');
+  if (re.unicode || re.unicodeSets)
+    return String(re);
+  return String(re).replace(/(^|[^\\])(\\\\)*(["'`])/g, "$1$2\\$3").replace(/>>/g, "\\>\\>");
 }
 function escapeForTextSelector(text, exact) {
-  if (typeof text !== 'string') return escapeRegexForSelector(text);
-  return `${JSON.stringify(text)}${exact ? 's' : 'i'}`;
+  if (typeof text !== "string")
+    return escapeRegexForSelector(text);
+  return `${JSON.stringify(text)}${exact ? "s" : "i"}`;
 }
 function escapeForAttributeSelector(value, exact) {
-  if (typeof value !== 'string') return escapeRegexForSelector(value);
-  // TODO: this should actually be
-  //   cssEscape(value).replace(/\\ /g, ' ')
-  // However, our attribute selectors do not conform to CSS parsing spec,
-  // so we escape them differently.
-  return `"${value.replace(/\\/g, '\\\\').replace(/["]/g, '\\"')}"${exact ? 's' : 'i'}`;
-}
-function trimString(input, cap, suffix = '') {
-  if (input.length <= cap) return input;
+  if (typeof value !== "string")
+    return escapeRegexForSelector(value);
+  return `"${value.replace(/\\/g, "\\\\").replace(/["]/g, '\\"')}"${exact ? "s" : "i"}`;
+}
+function trimString(input, cap, suffix = "") {
+  if (input.length <= cap)
+    return input;
   const chars = [...input];
-  if (chars.length > cap) return chars.slice(0, cap - suffix.length).join('') + suffix;
-  return chars.join('');
+  if (chars.length > cap)
+    return chars.slice(0, cap - suffix.length).join("") + suffix;
+  return chars.join("");
 }
 function trimStringWithEllipsis(input, cap) {
-  return trimString(input, cap, '\u2026');
+  return trimString(input, cap, "\u2026");
 }
 function escapeRegExp(s) {
-  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-}
-const escaped = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '\'': '&#39;'
-};
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const escaped = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
 function escapeHTMLAttribute(s) {
-  return s.replace(/[&<>"']/ug, char => escaped[char]);
+  return s.replace(/[&<>"']/ug, (char) => escaped[char]);
 }
 function escapeHTML(s) {
-  return s.replace(/[&<]/ug, char => escaped[char]);
+  return s.replace(/[&<]/ug, (char) => escaped[char]);
 }
 function longestCommonSubstring(s1, s2) {
   const n = s1.length;
   const m = s2.length;
   let maxLen = 0;
   let endingIndex = 0;
-
-  // Initialize a 2D array with zeros
   const dp = Array(n + 1).fill(null).map(() => Array(m + 1).fill(0));
-
-  // Build the dp table
   for (let i = 1; i <= n; i++) {
     for (let j = 1; j <= m; j++) {
       if (s1[i - 1] === s2[j - 1]) {
@@ -163,7 +151,26 @@ function longestCommonSubstring(s1, s2) {
       }
     }
   }
-
-  // Extract the longest common substring
   return s1.slice(endingIndex - maxLen, endingIndex);
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheNormalizedWhitespaces,
+  cssEscape,
+  escapeForAttributeSelector,
+  escapeForTextSelector,
+  escapeHTML,
+  escapeHTMLAttribute,
+  escapeRegExp,
+  escapeTemplateString,
+  escapeWithQuotes,
+  isString,
+  longestCommonSubstring,
+  normalizeEscapedRegexQuotes,
+  normalizeWhiteSpace,
+  quoteCSSAttributeValue,
+  toSnakeCase,
+  toTitleCase,
+  trimString,
+  trimStringWithEllipsis
+});