eslint-plugin-yml 1.10.0 → 1.12.0

package/lib/meta.d.ts

@@ -1,2 +1,2 @@
 export declare const name: "eslint-plugin-yml";
-export declare const version: "1.10.0";
+export declare const version: "1.12.0";

package/lib/meta.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = "eslint-plugin-yml";
-exports.version = "1.10.0";
+exports.version = "1.12.0";

package/lib/rules/flow-mapping-curly-spacing.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const compat_1 = require("../utils/compat");
-const coreRule = (0, utils_1.getCoreRule)("object-curly-spacing");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("flow-mapping-curly-spacing", {
     meta: {
         docs: {
@@ -11,33 +11,181 @@ exports.default = (0, utils_1.createRule)("flow-mapping-curly-spacing", {
             extensionRule: "object-curly-spacing",
             layout: true,
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                type: "string",
+                enum: ["always", "never"],
+            },
+            {
+                type: "object",
+                properties: {
+                    arraysInObjects: {
+                        type: "boolean",
+                    },
+                    objectsInObjects: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireSpaceBefore: "A space is required before '{{token}}'.",
+            requireSpaceAfter: "A space is required after '{{token}}'.",
+            unexpectedSpaceBefore: "There should be no space before '{{token}}'.",
+            unexpectedSpaceAfter: "There should be no space after '{{token}}'.",
+        },
     },
     create(context) {
         const sourceCode = (0, compat_1.getSourceCode)(context);
         if (!sourceCode.parserServices.isYAML) {
             return {};
         }
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: context.options,
-            createListenerProxy(listener) {
-                return {
-                    YAMLMapping(node) {
-                        if (node.style === "flow") {
-                            listener.ObjectExpression((0, utils_1.getProxyNode)(node, {
-                                type: "ObjectExpression",
-                                get properties() {
-                                    return node.pairs;
-                                },
-                            }));
-                        }
-                    },
-                };
+        const spaced = context.options[0] === "always";
+        function isOptionSet(option) {
+            return context.options[1]
+                ? context.options[1][option] === !spaced
+                : false;
+        }
+        const options = {
+            spaced,
+            arraysInObjectsException: isOptionSet("arraysInObjects"),
+            objectsInObjectsException: isOptionSet("objectsInObjects"),
+            isOpeningCurlyBraceMustBeSpaced(second) {
+                var _a;
+                const targetPenultimateType = options.arraysInObjectsException && (0, ast_utils_1.isOpeningBracketToken)(second)
+                    ? "YAMLSequence"
+                    : options.objectsInObjectsException && (0, ast_utils_1.isOpeningBraceToken)(second)
+                        ? "YAMLMapping"
+                        : null;
+                return targetPenultimateType &&
+                    ((_a = sourceCode.getNodeByRangeIndex(second.range[0])) === null || _a === void 0 ? void 0 : _a.type) ===
+                        targetPenultimateType
+                    ? !options.spaced
+                    : options.spaced;
+            },
+            isClosingCurlyBraceMustBeSpaced(penultimate) {
+                var _a;
+                const targetPenultimateType = options.arraysInObjectsException && (0, ast_utils_1.isClosingBracketToken)(penultimate)
+                    ? "YAMLSequence"
+                    : options.objectsInObjectsException &&
+                        (0, ast_utils_1.isClosingBraceToken)(penultimate)
+                        ? "YAMLMapping"
+                        : null;
+                return targetPenultimateType &&
+                    ((_a = sourceCode.getNodeByRangeIndex(penultimate.range[0])) === null || _a === void 0 ? void 0 : _a.type) ===
+                        targetPenultimateType
+                    ? !options.spaced
+                    : options.spaced;
+            },
+        };
+        function reportNoBeginningSpace(node, token) {
+            const nextToken = sourceCode.getTokenAfter(token, {
+                includeComments: true,
+            });
+            context.report({
+                node,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
+                messageId: "unexpectedSpaceAfter",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                },
+            });
+        }
+        function reportNoEndingSpace(node, token) {
+            const previousToken = sourceCode.getTokenBefore(token, {
+                includeComments: true,
+            });
+            context.report({
+                node,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
+                messageId: "unexpectedSpaceBefore",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
+                },
+            });
+        }
+        function reportRequiredBeginningSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "requireSpaceAfter",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextAfter(token, " ");
+                },
+            });
+        }
+        function reportRequiredEndingSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "requireSpaceBefore",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextBefore(token, " ");
+                },
+            });
+        }
+        function validateBraceSpacing(node, first, second, penultimate, last) {
+            if ((0, ast_utils_1.isTokenOnSameLine)(first, second)) {
+                const firstSpaced = sourceCode.isSpaceBetweenTokens(first, second);
+                if (options.isOpeningCurlyBraceMustBeSpaced(second)) {
+                    if (!firstSpaced)
+                        reportRequiredBeginningSpace(node, first);
+                }
+                else {
+                    if (firstSpaced && second.type !== "Line")
+                        reportNoBeginningSpace(node, first);
+                }
+            }
+            if ((0, ast_utils_1.isTokenOnSameLine)(penultimate, last)) {
+                const lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last);
+                if (options.isClosingCurlyBraceMustBeSpaced(penultimate)) {
+                    if (!lastSpaced)
+                        reportRequiredEndingSpace(node, last);
+                }
+                else {
+                    if (lastSpaced)
+                        reportNoEndingSpace(node, last);
+                }
+            }
+        }
+        function getClosingBraceOfObject(node) {
+            const lastProperty = node.pairs[node.pairs.length - 1];
+            return sourceCode.getTokenAfter(lastProperty, ast_utils_1.isClosingBraceToken);
+        }
+        function checkForObject(node) {
+            if (node.pairs.length === 0)
+                return;
+            const first = sourceCode.getFirstToken(node);
+            const last = getClosingBraceOfObject(node);
+            const second = sourceCode.getTokenAfter(first, {
+                includeComments: true,
+            });
+            const penultimate = sourceCode.getTokenBefore(last, {
+                includeComments: true,
+            });
+            validateBraceSpacing(node, first, second, penultimate, last);
+        }
+        return {
+            YAMLMapping(node) {
+                if (node.style === "flow") {
+                    checkForObject(node);
+                }
             },
-        });
+        };
     },
 });

package/lib/rules/flow-sequence-bracket-spacing.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const compat_1 = require("../utils/compat");
-const coreRule = (0, utils_1.getCoreRule)("array-bracket-spacing");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("flow-sequence-bracket-spacing", {
     meta: {
         docs: {
@@ -11,33 +11,173 @@ exports.default = (0, utils_1.createRule)("flow-sequence-bracket-spacing", {
             extensionRule: "array-bracket-spacing",
             layout: true,
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                type: "string",
+                enum: ["always", "never"],
+            },
+            {
+                type: "object",
+                properties: {
+                    singleValue: {
+                        type: "boolean",
+                    },
+                    objectsInArrays: {
+                        type: "boolean",
+                    },
+                    arraysInArrays: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpectedSpaceAfter: "There should be no space after '{{tokenValue}}'.",
+            unexpectedSpaceBefore: "There should be no space before '{{tokenValue}}'.",
+            missingSpaceAfter: "A space is required after '{{tokenValue}}'.",
+            missingSpaceBefore: "A space is required before '{{tokenValue}}'.",
+        },
     },
     create(context) {
         const sourceCode = (0, compat_1.getSourceCode)(context);
         if (!sourceCode.parserServices.isYAML) {
             return {};
         }
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: context.options,
-            createListenerProxy(listener) {
-                return {
-                    YAMLSequence(node) {
-                        if (node.style === "flow") {
-                            listener.ArrayExpression((0, utils_1.getProxyNode)(node, {
-                                type: "ArrayExpression",
-                                get elements() {
-                                    return node.entries;
-                                },
-                            }));
-                        }
-                    },
-                };
+        const spaced = context.options[0] === "always";
+        function isOptionSet(option) {
+            return context.options[1]
+                ? context.options[1][option] === !spaced
+                : false;
+        }
+        const options = {
+            spaced,
+            singleElementException: isOptionSet("singleValue"),
+            objectsInArraysException: isOptionSet("objectsInArrays"),
+            arraysInArraysException: isOptionSet("arraysInArrays"),
+            isOpeningBracketMustBeSpaced(node) {
+                if (options.singleElementException && node.entries.length === 1) {
+                    return !options.spaced;
+                }
+                const firstElement = node.entries[0];
+                return firstElement &&
+                    ((options.objectsInArraysException && isObjectType(firstElement)) ||
+                        (options.arraysInArraysException && isArrayType(firstElement)))
+                    ? !options.spaced
+                    : options.spaced;
+            },
+            isClosingBracketMustBeSpaced(node) {
+                if (options.singleElementException && node.entries.length === 1) {
+                    return !options.spaced;
+                }
+                const lastElement = node.entries[node.entries.length - 1];
+                return lastElement &&
+                    ((options.objectsInArraysException && isObjectType(lastElement)) ||
+                        (options.arraysInArraysException && isArrayType(lastElement)))
+                    ? !options.spaced
+                    : options.spaced;
+            },
+        };
+        function reportNoBeginningSpace(node, token) {
+            const nextToken = sourceCode.getTokenAfter(token);
+            context.report({
+                node,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
+                messageId: "unexpectedSpaceAfter",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                },
+            });
+        }
+        function reportNoEndingSpace(node, token) {
+            const previousToken = sourceCode.getTokenBefore(token);
+            context.report({
+                node,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
+                messageId: "unexpectedSpaceBefore",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
+                },
+            });
+        }
+        function reportRequiredBeginningSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingSpaceAfter",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextAfter(token, " ");
+                },
+            });
+        }
+        function reportRequiredEndingSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingSpaceBefore",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextBefore(token, " ");
+                },
+            });
+        }
+        function isObjectType(node) {
+            return node && node.type === "YAMLMapping";
+        }
+        function isArrayType(node) {
+            return node && node.type === "YAMLSequence";
+        }
+        function validateArraySpacing(node) {
+            if (options.spaced && node.entries.length === 0)
+                return;
+            const first = sourceCode.getFirstToken(node);
+            const last = sourceCode.getLastToken(node);
+            const second = sourceCode.getTokenAfter(first, {
+                includeComments: true,
+            });
+            const penultimate = sourceCode.getTokenBefore(last, {
+                includeComments: true,
+            });
+            if ((0, ast_utils_1.isTokenOnSameLine)(first, second)) {
+                if (options.isOpeningBracketMustBeSpaced(node)) {
+                    if (!sourceCode.isSpaceBetweenTokens(first, second))
+                        reportRequiredBeginningSpace(node, first);
+                }
+                else {
+                    if (sourceCode.isSpaceBetweenTokens(first, second))
+                        reportNoBeginningSpace(node, first);
+                }
+            }
+            if (first !== penultimate && (0, ast_utils_1.isTokenOnSameLine)(penultimate, last)) {
+                if (options.isClosingBracketMustBeSpaced(node)) {
+                    if (!sourceCode.isSpaceBetweenTokens(penultimate, last))
+                        reportRequiredEndingSpace(node, last);
+                }
+                else {
+                    if (sourceCode.isSpaceBetweenTokens(penultimate, last))
+                        reportNoEndingSpace(node, last);
+                }
+            }
+        }
+        return {
+            YAMLSequence(node) {
+                if (node.style === "flow") {
+                    validateArraySpacing(node);
+                }
             },
-        });
+        };
     },
 });

package/lib/rules/plain-scalar.js

@@ -1,8 +1,4 @@
 "use strict";
-var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const yaml_eslint_parser_1 = require("yaml-eslint-parser");
 const utils_1 = require("../utils");
@@ -67,7 +63,7 @@ exports.default = (0, utils_1.createRule)("plain-scalar", {
         const option = context.options[0] || "always";
         const ignorePatterns = toRegExps((_b = (_a = context.options[1]) === null || _a === void 0 ? void 0 : _a.ignorePatterns) !== null && _b !== void 0 ? _b : (option === "always"
             ? [
-                String.raw(templateObject_1 || (templateObject_1 = __makeTemplateObject(["[\v\f\u0085\u00A0\u1680\u180E\u2000-\u200B\u2028\u2029\u202F\u205F\u3000\uFEFF]"], ["[\\v\\f\\u0085\\u00a0\\u1680\\u180e\\u2000-\\u200b\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]"]))),
+                String.raw `[\v\f\u0085\u00a0\u1680\u180e\u2000-\u200b\u2028\u2029\u202f\u205f\u3000\ufeff]`,
             ]
             : []));
         let currentDocument;
@@ -171,4 +167,3 @@ exports.default = (0, utils_1.createRule)("plain-scalar", {
         };
     },
 });
-var templateObject_1;

package/lib/rules/sort-keys.js

@@ -63,7 +63,7 @@ class YAMLMappingData {
         while (p) {
             if (p.type === "YAMLPair") {
                 const name = getPropertyName(p, sourceCode);
-                if (/^[$_a-z][\w$]*$/iu.test(name)) {
+                if (/^[$a-z_][\w$]*$/iu.test(name)) {
                     path = `.${name}${path}`;
                 }
                 else {

package/lib/rules/sort-sequence-values.js

@@ -181,7 +181,7 @@ function parseOptions(options, sourceCode) {
             while (p) {
                 if (p.type === "YAMLPair") {
                     const name = getPropertyName(p);
-                    if (/^[$_a-z][\w$]*$/iu.test(name)) {
+                    if (/^[$a-z_][\w$]*$/iu.test(name)) {
                         path = `.${name}${path}`;
                     }
                     else {

package/lib/utils/ast-utils.d.ts

@@ -5,3 +5,7 @@ export declare function isQuestion(token: YAMLToken | null): token is YAMLToken;
 export declare function isHyphen(token: YAMLToken | null): token is YAMLToken;
 export declare function isColon(token: YAMLToken | null): token is YAMLToken;
 export declare function isComma(token: YAMLToken | null): token is YAMLToken;
+export declare function isOpeningBracketToken(token: YAMLToken | null): token is YAMLToken;
+export declare function isClosingBracketToken(token: YAMLToken | null): token is YAMLToken;
+export declare function isOpeningBraceToken(token: YAMLToken | null): token is YAMLToken;
+export declare function isClosingBraceToken(token: YAMLToken | null): token is YAMLToken;

package/lib/utils/ast-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isComma = exports.isColon = exports.isHyphen = exports.isQuestion = exports.isTokenOnSameLine = exports.isCommentToken = void 0;
+exports.isClosingBraceToken = exports.isOpeningBraceToken = exports.isClosingBracketToken = exports.isOpeningBracketToken = exports.isComma = exports.isColon = exports.isHyphen = exports.isQuestion = exports.isTokenOnSameLine = exports.isCommentToken = void 0;
 function isCommentToken(token) {
     return Boolean(token && (token.type === "Block" || token.type === "Line"));
 }
@@ -25,3 +25,19 @@ function isComma(token) {
     return token != null && token.type === "Punctuator" && token.value === ",";
 }
 exports.isComma = isComma;
+function isOpeningBracketToken(token) {
+    return token != null && token.value === "[" && token.type === "Punctuator";
+}
+exports.isOpeningBracketToken = isOpeningBracketToken;
+function isClosingBracketToken(token) {
+    return token != null && token.value === "]" && token.type === "Punctuator";
+}
+exports.isClosingBracketToken = isClosingBracketToken;
+function isOpeningBraceToken(token) {
+    return token != null && token.value === "{" && token.type === "Punctuator";
+}
+exports.isOpeningBraceToken = isOpeningBraceToken;
+function isClosingBraceToken(token) {
+    return token != null && token.value === "}" && token.type === "Punctuator";
+}
+exports.isClosingBraceToken = isClosingBraceToken;

package/lib/utils/index.d.ts

@@ -1,15 +1,2 @@
-import type { RuleListener, RuleModule, PartialRuleModule, RuleContext } from "../types";
-import type { Rule } from "eslint";
-import type { AST } from "yaml-eslint-parser";
+import type { RuleModule, PartialRuleModule } from "../types";
 export declare function createRule(ruleName: string, rule: PartialRuleModule): RuleModule;
-type CoreRuleListener = {
-    [key: string]: (node: any) => void;
-};
-export declare function defineWrapperListener(coreRule: Rule.RuleModule, context: RuleContext, proxyOptions: {
-    options: any[];
-    createListenerProxy?: (listener: CoreRuleListener) => RuleListener;
-}): RuleListener;
-export declare function getProxyNode(node: AST.YAMLNode, properties: any): any;
-export declare function isNode(data: any): boolean;
-export declare function getCoreRule(ruleName: string): Rule.RuleModule;
-export {};

package/lib/utils/index.js

@@ -26,12 +26,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCoreRule = exports.isNode = exports.getProxyNode = exports.defineWrapperListener = exports.createRule = void 0;
+exports.createRule = void 0;
 const yamlESLintParser = __importStar(require("yaml-eslint-parser"));
-const debug_1 = __importDefault(require("debug"));
 const path_1 = __importDefault(require("path"));
 const compat_1 = require("./compat");
-const log = (0, debug_1.default)("eslint-plugin-yml:utils/index");
 function createRule(ruleName, rule) {
     return {
         meta: Object.assign(Object.assign({}, rule.meta), { docs: Object.assign(Object.assign({}, rule.meta.docs), { url: `https://ota-meshi.github.io/eslint-plugin-yml/rules/${ruleName}.html`, ruleId: `yml/${ruleName}`, ruleName }) }),
@@ -56,60 +54,3 @@ function createRule(ruleName, rule) {
     };
 }
 exports.createRule = createRule;
-function defineWrapperListener(coreRule, context, proxyOptions) {
-    var _a, _b;
-    const sourceCode = (0, compat_1.getSourceCode)(context);
-    if (!sourceCode.parserServices.isYAML) {
-        return {};
-    }
-    const listener = coreRule.create({
-        __proto__: context,
-        options: proxyOptions.options,
-    });
-    const yamlListener = (_b = (_a = proxyOptions.createListenerProxy) === null || _a === void 0 ? void 0 : _a.call(proxyOptions, listener)) !== null && _b !== void 0 ? _b : listener;
-    return yamlListener;
-}
-exports.defineWrapperListener = defineWrapperListener;
-function getProxyNode(node, properties) {
-    const safeKeys = new Set([
-        "range",
-        "typeAnnotation",
-    ]);
-    const cache = {};
-    return new Proxy(node, {
-        get(_t, key) {
-            if (key in cache) {
-                return cache[key];
-            }
-            if (key in properties) {
-                return (cache[key] = properties[key]);
-            }
-            if (!safeKeys.has(key)) {
-                log(`fallback: ${String(key)}`);
-            }
-            return node[key];
-        },
-    });
-}
-exports.getProxyNode = getProxyNode;
-function isNode(data) {
-    return (data &&
-        typeof data.type === "string" &&
-        Array.isArray(data.range) &&
-        data.range.length === 2 &&
-        typeof data.range[0] === "number" &&
-        typeof data.range[1] === "number");
-}
-exports.isNode = isNode;
-let ruleMap = null;
-function getCoreRule(ruleName) {
-    let map;
-    if (ruleMap) {
-        map = ruleMap;
-    }
-    else {
-        ruleMap = map = new (require("eslint").Linter)().getRules();
-    }
-    return map.get(ruleName);
-}
-exports.getCoreRule = getCoreRule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-yml",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "This ESLint plugin provides linting rules for YAML.",
   "main": "lib/index.js",
   "files": [
@@ -57,7 +57,7 @@
   "homepage": "https://ota-meshi.github.io/eslint-plugin-yml/",
   "dependencies": {
     "debug": "^4.3.2",
-    "eslint-compat-utils": "^0.1.0",
+    "eslint-compat-utils": "^0.2.1",
     "lodash": "^4.17.21",
     "natural-compare": "^1.4.0",
     "yaml-eslint-parser": "^1.2.1"
@@ -66,7 +66,7 @@
     "eslint": ">=6.0.0"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.4.6",
+    "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.24.2",
     "@ota-meshi/eslint-plugin": "^0.15.0",
     "@ota-meshi/site-kit-eslint-editor-vue": "^0.1.2",
@@ -78,7 +78,7 @@
     "@types/lodash": "^4.14.158",
     "@types/mocha": "^10.0.0",
     "@types/natural-compare": "^1.4.0",
-    "@types/node": "^18.0.0",
+    "@types/node": "^20.0.0",
     "@types/semver": "^7.3.1",
     "@typescript-eslint/eslint-plugin": "^6.0.0",
     "@typescript-eslint/parser": "^6.0.0",
@@ -90,30 +90,30 @@
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-eslint-plugin": "^5.0.0",
-    "eslint-plugin-json-schema-validator": "^4.0.0",
+    "eslint-plugin-json-schema-validator": "^4.7.4",
     "eslint-plugin-jsonc": "^2.0.0",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-n": "^16.0.1",
     "eslint-plugin-node-dependencies": "^0.11.0",
     "eslint-plugin-prettier": "^5.0.0",
-    "eslint-plugin-regexp": "^1.0.0",
+    "eslint-plugin-regexp": "^2.0.0",
     "eslint-plugin-vue": "^9.0.0",
     "eslint-plugin-yml": "^1.0.0",
     "espree": "^9.0.0",
     "events": "^3.3.0",
     "mocha": "^10.0.0",
-    "monaco-editor": "^0.44.0",
+    "monaco-editor": "^0.45.0",
     "nyc": "^15.1.0",
     "pako": "^2.1.0",
     "prettier": "^3.0.3",
     "semver": "^7.3.2",
-    "stylelint": "^15.0.0",
+    "stylelint": "^16.0.0",
     "stylelint-config-recommended-vue": "^1.0.0",
-    "stylelint-config-standard": "^34.0.0",
+    "stylelint-config-standard": "^36.0.0",
     "stylelint-config-standard-vue": "^1.0.0",
-    "stylelint-stylus": "^0.18.0",
-    "typescript": "~5.2.0",
-    "vite-plugin-eslint4b": "^0.2.1",
+    "stylelint-stylus": "^1.0.0",
+    "typescript": "~5.3.0",
+    "vite-plugin-eslint4b": "^0.2.3",
     "vitepress": "^1.0.0-rc.17",
     "vue-eslint-parser": "^9.0.0",
     "yaml": "^2.1.1"