immosquare-cleaner 0.1.32 → 0.1.33

data/node_modules/eslint/lib/rules/utils/char-source.js

@@ -0,0 +1,240 @@
+/**
+ * @fileoverview Utility functions to locate the source text of each code unit in the value of a string literal or template token.
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+/**
+ * Represents a code unit produced by the evaluation of a JavaScript common token like a string
+ * literal or template token.
+ */
+class CodeUnit {
+    constructor(start, source) {
+        this.start = start;
+        this.source = source;
+    }
+
+    get end() {
+        return this.start + this.length;
+    }
+
+    get length() {
+        return this.source.length;
+    }
+}
+
+/**
+ * An object used to keep track of the position in a source text where the next characters will be read.
+ */
+class TextReader {
+    constructor(source) {
+        this.source = source;
+        this.pos = 0;
+    }
+
+    /**
+     * Advances the reading position of the specified number of characters.
+     * @param {number} length Number of characters to advance.
+     * @returns {void}
+     */
+    advance(length) {
+        this.pos += length;
+    }
+
+    /**
+     * Reads characters from the source.
+     * @param {number} [offset=0] The offset where reading starts, relative to the current position.
+     * @param {number} [length=1] Number of characters to read.
+     * @returns {string} A substring of source characters.
+     */
+    read(offset = 0, length = 1) {
+        const start = offset + this.pos;
+
+        return this.source.slice(start, start + length);
+    }
+}
+
+const SIMPLE_ESCAPE_SEQUENCES =
+{ __proto__: null, b: "\b", f: "\f", n: "\n", r: "\r", t: "\t", v: "\v" };
+
+/**
+ * Reads a hex escape sequence.
+ * @param {TextReader} reader The reader should be positioned on the first hexadecimal digit.
+ * @param {number} length The number of hexadecimal digits.
+ * @returns {string} A code unit.
+ */
+function readHexSequence(reader, length) {
+    const str = reader.read(0, length);
+    const charCode = parseInt(str, 16);
+
+    reader.advance(length);
+    return String.fromCharCode(charCode);
+}
+
+/**
+ * Reads a Unicode escape sequence.
+ * @param {TextReader} reader The reader should be positioned after the "u".
+ * @returns {string} A code unit.
+ */
+function readUnicodeSequence(reader) {
+    const regExp = /\{(?<hexDigits>[\dA-Fa-f]+)\}/uy;
+
+    regExp.lastIndex = reader.pos;
+    const match = regExp.exec(reader.source);
+
+    if (match) {
+        const codePoint = parseInt(match.groups.hexDigits, 16);
+
+        reader.pos = regExp.lastIndex;
+        return String.fromCodePoint(codePoint);
+    }
+    return readHexSequence(reader, 4);
+}
+
+/**
+ * Reads an octal escape sequence.
+ * @param {TextReader} reader The reader should be positioned after the first octal digit.
+ * @param {number} maxLength The maximum number of octal digits.
+ * @returns {string} A code unit.
+ */
+function readOctalSequence(reader, maxLength) {
+    const [octalStr] = reader.read(-1, maxLength).match(/^[0-7]+/u);
+
+    reader.advance(octalStr.length - 1);
+    const octal = parseInt(octalStr, 8);
+
+    return String.fromCharCode(octal);
+}
+
+/**
+ * Reads an escape sequence or line continuation.
+ * @param {TextReader} reader The reader should be positioned on the backslash.
+ * @returns {string} A string of zero, one or two code units.
+ */
+function readEscapeSequenceOrLineContinuation(reader) {
+    const char = reader.read(1);
+
+    reader.advance(2);
+    const unitChar = SIMPLE_ESCAPE_SEQUENCES[char];
+
+    if (unitChar) {
+        return unitChar;
+    }
+    switch (char) {
+        case "x":
+            return readHexSequence(reader, 2);
+        case "u":
+            return readUnicodeSequence(reader);
+        case "\r":
+            if (reader.read() === "\n") {
+                reader.advance(1);
+            }
+
+            // fallthrough
+        case "\n":
+        case "\u2028":
+        case "\u2029":
+            return "";
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+            return readOctalSequence(reader, 3);
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+            return readOctalSequence(reader, 2);
+        default:
+            return char;
+    }
+}
+
+/**
+ * Reads an escape sequence or line continuation and generates the respective `CodeUnit` elements.
+ * @param {TextReader} reader The reader should be positioned on the backslash.
+ * @returns {Generator<CodeUnit>} Zero, one or two `CodeUnit` elements.
+ */
+function *mapEscapeSequenceOrLineContinuation(reader) {
+    const start = reader.pos;
+    const str = readEscapeSequenceOrLineContinuation(reader);
+    const end = reader.pos;
+    const source = reader.source.slice(start, end);
+
+    switch (str.length) {
+        case 0:
+            break;
+        case 1:
+            yield new CodeUnit(start, source);
+            break;
+        default:
+            yield new CodeUnit(start, source);
+            yield new CodeUnit(start, source);
+            break;
+    }
+}
+
+/**
+ * Parses a string literal.
+ * @param {string} source The string literal to parse, including the delimiting quotes.
+ * @returns {CodeUnit[]} A list of code units produced by the string literal.
+ */
+function parseStringLiteral(source) {
+    const reader = new TextReader(source);
+    const quote = reader.read();
+
+    reader.advance(1);
+    const codeUnits = [];
+
+    for (;;) {
+        const char = reader.read();
+
+        if (char === quote) {
+            break;
+        }
+        if (char === "\\") {
+            codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
+        } else {
+            codeUnits.push(new CodeUnit(reader.pos, char));
+            reader.advance(1);
+        }
+    }
+    return codeUnits;
+}
+
+/**
+ * Parses a template token.
+ * @param {string} source The template token to parse, including the delimiting sequences `` ` ``, `${` and `}`.
+ * @returns {CodeUnit[]} A list of code units produced by the template token.
+ */
+function parseTemplateToken(source) {
+    const reader = new TextReader(source);
+
+    reader.advance(1);
+    const codeUnits = [];
+
+    for (;;) {
+        const char = reader.read();
+
+        if (char === "`" || char === "$" && reader.read(1) === "{") {
+            break;
+        }
+        if (char === "\\") {
+            codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
+        } else {
+            let unitSource;
+
+            if (char === "\r" && reader.read(1) === "\n") {
+                unitSource = "\r\n";
+            } else {
+                unitSource = char;
+            }
+            codeUnits.push(new CodeUnit(reader.pos, unitSource));
+            reader.advance(unitSource.length);
+        }
+    }
+    return codeUnits;
+}
+
+module.exports = { parseStringLiteral, parseTemplateToken };

data/node_modules/eslint/lib/rules/utils/lazy-loading-rule-map.js

@@ -6,7 +6,7 @@
 
 const debug = require("debug")("eslint:rules");
 
-/** @typedef {import("./types").Rule} Rule */
+/** @typedef {import("../../shared/types").Rule} Rule */
 
 /**
  * The `Map` object that loads each rule when it's accessed.

data/node_modules/eslint/lib/rules/utils/unicode/index.js

@@ -3,9 +3,14 @@
  */
 "use strict";
 
+const isCombiningCharacter = require("./is-combining-character");
+const isEmojiModifier = require("./is-emoji-modifier");
+const isRegionalIndicatorSymbol = require("./is-regional-indicator-symbol");
+const isSurrogatePair = require("./is-surrogate-pair");
+
 module.exports = {
-    isCombiningCharacter: require("./is-combining-character"),
-    isEmojiModifier: require("./is-emoji-modifier"),
-    isRegionalIndicatorSymbol: require("./is-regional-indicator-symbol"),
-    isSurrogatePair: require("./is-surrogate-pair")
+    isCombiningCharacter,
+    isEmojiModifier,
+    isRegionalIndicatorSymbol,
+    isSurrogatePair
 };

data/node_modules/eslint/lib/rules/yield-star-spacing.js

@@ -79,7 +79,7 @@ module.exports = {
                 const after = leftToken.value === "*";
                 const spaceRequired = mode[side];
                 const node = after ? leftToken : rightToken;
-                let messageId = "";
+                let messageId;
 
                 if (spaceRequired) {
                     messageId = side === "before" ? "missingBefore" : "missingAfter";

data/node_modules/eslint/lib/shared/runtime-info.js

@@ -162,6 +162,7 @@ function version() {
 //------------------------------------------------------------------------------
 
 module.exports = {
+    __esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616)
     environment,
     version
 };

data/node_modules/eslint/lib/shared/serialization.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Serialization utils.
+ * @author Bryan Mishkin
+ */
+
+"use strict";
+
+/**
+ * Check if a value is a primitive or plain object created by the Object constructor.
+ * @param {any} val the value to check
+ * @returns {boolean} true if so
+ * @private
+ */
+function isSerializablePrimitiveOrPlainObject(val) {
+    return (
+        val === null ||
+        typeof val === "string" ||
+         typeof val === "boolean" ||
+         typeof val === "number" ||
+         (typeof val === "object" && val.constructor === Object) ||
+         Array.isArray(val)
+    );
+}
+
+/**
+ * Check if a value is serializable.
+ * Functions or objects like RegExp cannot be serialized by JSON.stringify().
+ * Inspired by: https://stackoverflow.com/questions/30579940/reliable-way-to-check-if-objects-is-serializable-in-javascript
+ * @param {any} val the value
+ * @returns {boolean} true if the value is serializable
+ */
+function isSerializable(val) {
+    if (!isSerializablePrimitiveOrPlainObject(val)) {
+        return false;
+    }
+    if (typeof val === "object") {
+        for (const property in val) {
+            if (Object.hasOwn(val, property)) {
+                if (!isSerializablePrimitiveOrPlainObject(val[property])) {
+                    return false;
+                }
+                if (typeof val[property] === "object") {
+                    if (!isSerializable(val[property])) {
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    return true;
+}
+
+module.exports = {
+    isSerializable
+};

data/node_modules/eslint/lib/shared/stats.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Provides helper functions to start/stop the time measurements
+ * that are provided by the ESLint 'stats' option.
+ * @author Mara Kiefer <http://github.com/mnkiefer>
+ */
+"use strict";
+
+/**
+ * Start time measurement
+ * @returns {[number, number]} t variable for tracking time
+ */
+function startTime() {
+    return process.hrtime();
+}
+
+/**
+ * End time measurement
+ * @param {[number, number]} t Variable for tracking time
+ * @returns {number} The measured time in milliseconds
+ */
+function endTime(t) {
+    const time = process.hrtime(t);
+
+    return time[0] * 1e3 + time[1] / 1e6;
+}
+
+module.exports = {
+    startTime,
+    endTime
+};

data/node_modules/eslint/lib/shared/string-utils.js

@@ -5,12 +5,6 @@
 
 "use strict";
 
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const Graphemer = require("graphemer").default;
-
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -18,8 +12,8 @@ const Graphemer = require("graphemer").default;
 // eslint-disable-next-line no-control-regex -- intentionally including control characters
 const ASCII_REGEX = /^[\u0000-\u007f]*$/u;
 
-/** @type {Graphemer | undefined} */
-let splitter;
+/** @type {Intl.Segmenter | undefined} */
+let segmenter;
 
 //------------------------------------------------------------------------------
 // Public Interface
@@ -47,11 +41,15 @@ function getGraphemeCount(value) {
         return value.length;
     }
 
-    if (!splitter) {
-        splitter = new Graphemer();
+    segmenter ??= new Intl.Segmenter("en-US"); // en-US locale should be supported everywhere
+    let graphemeCount = 0;
+
+    // eslint-disable-next-line no-unused-vars -- for-of needs a variable
+    for (const unused of segmenter.segment(value)) {
+        graphemeCount++;
     }
 
-    return splitter.countGraphemes(value);
+    return graphemeCount;
 }
 
 module.exports = {

data/node_modules/eslint/lib/shared/types.js

@@ -168,7 +168,7 @@ module.exports = {};
  * @property {Record<string, ConfigData>} [configs] The definition of plugin configs.
  * @property {Record<string, Environment>} [environments] The definition of plugin environments.
  * @property {Record<string, Processor>} [processors] The definition of plugin processors.
- * @property {Record<string, Function | Rule>} [rules] The definition of plugin rules.
+ * @property {Record<string, Rule>} [rules] The definition of plugin rules.
  */
 
 /**
@@ -189,11 +189,45 @@ module.exports = {};
  * @property {number} warningCount Number of warnings for the result.
  * @property {number} fixableErrorCount Number of fixable errors for the result.
  * @property {number} fixableWarningCount Number of fixable warnings for the result.
+ * @property {Stats} [stats] The performance statistics collected with the `stats` flag.
  * @property {string} [source] The source code of the file that was linted.
  * @property {string} [output] The source code of the file that was linted, with as many fixes applied as possible.
  * @property {DeprecatedRuleInfo[]} usedDeprecatedRules The list of used deprecated rules.
  */
 
+/**
+ * Performance statistics
+ * @typedef {Object} Stats
+ * @property {number} fixPasses The number of times ESLint has applied at least one fix after linting.
+ * @property {Times} times The times spent on (parsing, fixing, linting) a file.
+ */
+
+/**
+ * Performance Times for each ESLint pass
+ * @typedef {Object} Times
+ * @property {TimePass[]} passes Time passes
+ */
+
+/**
+ * @typedef {Object} TimePass
+ * @property {ParseTime} parse The parse object containing all parse time information.
+ * @property {Record<string, RuleTime>} [rules] The rules object containing all lint time information for each rule.
+ * @property {FixTime} fix The parse object containing all fix time information.
+ * @property {number} total The total time that is spent on (parsing, fixing, linting) a file.
+ */
+/**
+ * @typedef {Object} ParseTime
+ * @property {number} total The total time that is spent when parsing a file.
+ */
+/**
+ * @typedef {Object} RuleTime
+ * @property {number} total The total time that is spent on a rule.
+ */
+/**
+ * @typedef {Object} FixTime
+ * @property {number} total The total time that is spent on applying fixes to the code.
+ */
+
 /**
  * Information provided when the maximum warning threshold is exceeded.
  * @typedef {Object} MaxWarningsExceeded

data/node_modules/eslint/lib/source-code/index.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const SourceCode = require("./source-code");
+
 module.exports = {
-    SourceCode: require("./source-code")
+    SourceCode
 };