@storm-software/linting-tools 1.125.29 → 1.125.30

package/README.md

@@ -21,7 +21,7 @@ This package is part of the <b>⚡Storm-Ops</b> monorepo. The Storm-Ops packages
 
 <h3 align="center">💻 Visit <a href="https://stormsoftware.com" target="_blank">stormsoftware.com</a> to stay up to date with this developer</h3><br />
 
-[![Version](https://img.shields.io/badge/version-1.125.28-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;[![Nx](https://img.shields.io/badge/Nx-17.0.2-lightgrey?style=for-the-badge&logo=nx&logoWidth=20&&color=1fb2a6)](http://nx.dev/)&nbsp;[![NextJs](https://img.shields.io/badge/Next.js-14.0.2-lightgrey?style=for-the-badge&logo=nextdotjs&logoWidth=20&color=1fb2a6)](https://nextjs.org/)&nbsp;[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=for-the-badge&logo=commitlint&color=1fb2a6)](http://commitizen.github.io/cz-cli/)&nbsp;![Semantic-Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=for-the-badge&color=1fb2a6)&nbsp;[![documented with Fumadocs](https://img.shields.io/badge/documented_with-fumadocs-success.svg?style=for-the-badge&logo=readthedocs&color=1fb2a6)](https://fumadocs.vercel.app/)&nbsp;![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/storm-software/storm-ops/cr.yml?style=for-the-badge&logo=github-actions&color=1fb2a6)
+[![Version](https://img.shields.io/badge/version-1.125.29-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;[![Nx](https://img.shields.io/badge/Nx-17.0.2-lightgrey?style=for-the-badge&logo=nx&logoWidth=20&&color=1fb2a6)](http://nx.dev/)&nbsp;[![NextJs](https://img.shields.io/badge/Next.js-14.0.2-lightgrey?style=for-the-badge&logo=nextdotjs&logoWidth=20&color=1fb2a6)](https://nextjs.org/)&nbsp;[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=for-the-badge&logo=commitlint&color=1fb2a6)](http://commitizen.github.io/cz-cli/)&nbsp;![Semantic-Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=for-the-badge&color=1fb2a6)&nbsp;[![documented with Fumadocs](https://img.shields.io/badge/documented_with-fumadocs-success.svg?style=for-the-badge&logo=readthedocs&color=1fb2a6)](https://fumadocs.vercel.app/)&nbsp;![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/storm-software/storm-ops/cr.yml?style=for-the-badge&logo=github-actions&color=1fb2a6)
 
 <!-- prettier-ignore-start -->
 <!-- markdownlint-disable -->

package/bin/lint.cjs

@@ -194,12 +194,12 @@ var require_jiti = _chunkM7MYTALKcjs.__commonJS.call(void 0, {
         }, Parser.tokenizer = function(input, options) {
           return new this(options, input);
         }, Object.defineProperties(Parser.prototype, prototypeAccessors);
-        var pp$9 = Parser.prototype, literal = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/;
+        var pp$9 = Parser.prototype, literal2 = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/;
         pp$9.strictDirective = function(start) {
           if (this.options.ecmaVersion < 5) return false;
           for (; ; ) {
             skipWhiteSpace.lastIndex = start, start += skipWhiteSpace.exec(this.input)[0].length;
-            var match4 = literal.exec(this.input.slice(start));
+            var match4 = literal2.exec(this.input.slice(start));
             if (!match4) return false;
             if ("use strict" === (match4[1] || match4[2])) {
               skipWhiteSpace.lastIndex = start + match4[0].length;
@@ -16052,17 +16052,17 @@ See https://babeljs.io/docs/configuration#print-effective-configs for more info.
             const startLoc = this.state.startLoc, endOfInit = () => this.match(12) || this.match(8);
             switch (this.state.type) {
               case 135: {
-                const literal = this.parseNumericLiteral(this.state.value);
-                return endOfInit() ? { type: "number", loc: literal.loc.start, value: literal } : { type: "invalid", loc: startLoc };
+                const literal2 = this.parseNumericLiteral(this.state.value);
+                return endOfInit() ? { type: "number", loc: literal2.loc.start, value: literal2 } : { type: "invalid", loc: startLoc };
               }
               case 134: {
-                const literal = this.parseStringLiteral(this.state.value);
-                return endOfInit() ? { type: "string", loc: literal.loc.start, value: literal } : { type: "invalid", loc: startLoc };
+                const literal2 = this.parseStringLiteral(this.state.value);
+                return endOfInit() ? { type: "string", loc: literal2.loc.start, value: literal2 } : { type: "invalid", loc: startLoc };
               }
               case 85:
               case 86: {
-                const literal = this.parseBooleanLiteral(this.match(85));
-                return endOfInit() ? { type: "boolean", loc: literal.loc.start, value: literal } : { type: "invalid", loc: startLoc };
+                const literal2 = this.parseBooleanLiteral(this.match(85));
+                return endOfInit() ? { type: "boolean", loc: literal2.loc.start, value: literal2 } : { type: "invalid", loc: startLoc };
               }
               default:
                 return { type: "invalid", loc: startLoc };
@@ -24615,9 +24615,9 @@ ${str2}
           return validate(defs.types, node, "types", types3, 1), node;
         }, exports2.tSIntrinsicKeyword = exports2.tsIntrinsicKeyword = function() {
           return { type: "TSIntrinsicKeyword" };
-        }, exports2.tSLiteralType = exports2.tsLiteralType = function(literal) {
-          const node = { type: "TSLiteralType", literal }, defs = NODE_FIELDS.TSLiteralType;
-          return validate(defs.literal, node, "literal", literal, 1), node;
+        }, exports2.tSLiteralType = exports2.tsLiteralType = function(literal2) {
+          const node = { type: "TSLiteralType", literal: literal2 }, defs = NODE_FIELDS.TSLiteralType;
+          return validate(defs.literal, node, "literal", literal2, 1), node;
         }, exports2.tSMappedType = exports2.tsMappedType = function(typeParameter, typeAnnotation = null, nameType = null) {
           const node = { type: "TSMappedType", typeParameter, typeAnnotation, nameType }, defs = NODE_FIELDS.TSMappedType;
           return validate(defs.typeParameter, node, "typeParameter", typeParameter, 1), validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1), validate(defs.nameType, node, "nameType", nameType, 1), node;
@@ -25863,9 +25863,9 @@ Expected ${val.length + 1} quasis but got ${node.quasis.length}`);
         defineType("TSFunctionType", Object.assign({}, fnOrCtrBase, { fields: signatureDeclarationCommon() })), defineType("TSConstructorType", Object.assign({}, fnOrCtrBase, { fields: Object.assign({}, signatureDeclarationCommon(), { abstract: (0, _utils.validateOptional)(bool2) }) })), defineType("TSTypeReference", { aliases: ["TSType"], visitor: ["typeName", "typeParameters"], fields: { typeName: (0, _utils.validateType)("TSEntityName"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }), defineType("TSTypePredicate", { aliases: ["TSType"], visitor: ["parameterName", "typeAnnotation"], builder: ["parameterName", "typeAnnotation", "asserts"], fields: { parameterName: (0, _utils.validateType)("Identifier", "TSThisType"), typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"), asserts: (0, _utils.validateOptional)(bool2) } }), defineType("TSTypeQuery", { aliases: ["TSType"], visitor: ["exprName", "typeParameters"], fields: { exprName: (0, _utils.validateType)("TSEntityName", "TSImportType"), typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation") } }), defineType("TSTypeLiteral", { aliases: ["TSType"], visitor: ["members"], fields: { members: (0, _utils.validateArrayOfType)("TSTypeElement") } }), defineType("TSArrayType", { aliases: ["TSType"], visitor: ["elementType"], fields: { elementType: (0, _utils.validateType)("TSType") } }), defineType("TSTupleType", { aliases: ["TSType"], visitor: ["elementTypes"], fields: { elementTypes: (0, _utils.validateArrayOfType)("TSType", "TSNamedTupleMember") } }), defineType("TSOptionalType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }), defineType("TSRestType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }), defineType("TSNamedTupleMember", { visitor: ["label", "elementType"], builder: ["label", "elementType", "optional"], fields: { label: (0, _utils.validateType)("Identifier"), optional: { validate: bool2, default: false }, elementType: (0, _utils.validateType)("TSType") } });
         const unionOrIntersection = { aliases: ["TSType"], visitor: ["types"], fields: { types: (0, _utils.validateArrayOfType)("TSType") } };
         defineType("TSUnionType", unionOrIntersection), defineType("TSIntersectionType", unionOrIntersection), defineType("TSConditionalType", { aliases: ["TSType"], visitor: ["checkType", "extendsType", "trueType", "falseType"], fields: { checkType: (0, _utils.validateType)("TSType"), extendsType: (0, _utils.validateType)("TSType"), trueType: (0, _utils.validateType)("TSType"), falseType: (0, _utils.validateType)("TSType") } }), defineType("TSInferType", { aliases: ["TSType"], visitor: ["typeParameter"], fields: { typeParameter: (0, _utils.validateType)("TSTypeParameter") } }), defineType("TSParenthesizedType", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { typeAnnotation: (0, _utils.validateType)("TSType") } }), defineType("TSTypeOperator", { aliases: ["TSType"], visitor: ["typeAnnotation"], fields: { operator: (0, _utils.validate)((0, _utils.assertValueType)("string")), typeAnnotation: (0, _utils.validateType)("TSType") } }), defineType("TSIndexedAccessType", { aliases: ["TSType"], visitor: ["objectType", "indexType"], fields: { objectType: (0, _utils.validateType)("TSType"), indexType: (0, _utils.validateType)("TSType") } }), defineType("TSMappedType", { aliases: ["TSType"], visitor: ["typeParameter", "nameType", "typeAnnotation"], builder: ["typeParameter", "typeAnnotation", "nameType"], fields: Object.assign({}, { typeParameter: (0, _utils.validateType)("TSTypeParameter") }, { readonly: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), optional: (0, _utils.validateOptional)((0, _utils.assertOneOf)(true, false, "+", "-")), typeAnnotation: (0, _utils.validateOptionalType)("TSType"), nameType: (0, _utils.validateOptionalType)("TSType") }) }), defineType("TSLiteralType", { aliases: ["TSType", "TSBaseType"], visitor: ["literal"], fields: { literal: { validate: function() {
-          const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral"), unaryOperator = (0, _utils.assertOneOf)("-"), literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
+          const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral"), unaryOperator = (0, _utils.assertOneOf)("-"), literal2 = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
           function validator(parent, key, node) {
-            (0, _is.default)("UnaryExpression", node) ? (unaryOperator(node, "operator", node.operator), unaryExpression(node, "argument", node.argument)) : literal(parent, key, node);
+            (0, _is.default)("UnaryExpression", node) ? (unaryOperator(node, "operator", node.operator), unaryExpression(node, "argument", node.argument)) : literal2(parent, key, node);
           }
           return validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral", "UnaryExpression"], validator;
         }() } } });
@@ -28431,11 +28431,11 @@ ${trace}`);
             case "[":
               return newToken("punctuator", read4());
             case "n":
-              return read4(), literal("ull"), newToken("null", null);
+              return read4(), literal2("ull"), newToken("null", null);
             case "t":
-              return read4(), literal("rue"), newToken("boolean", true);
+              return read4(), literal2("rue"), newToken("boolean", true);
             case "f":
-              return read4(), literal("alse"), newToken("boolean", false);
+              return read4(), literal2("alse"), newToken("boolean", false);
             case "-":
             case "+":
               return "-" === read4() && (sign2 = -1), void (lexState = "sign");
@@ -28454,9 +28454,9 @@ ${trace}`);
             case "9":
               return buffer = read4(), void (lexState = "decimalInteger");
             case "I":
-              return read4(), literal("nfinity"), newToken("numeric", 1 / 0);
+              return read4(), literal2("nfinity"), newToken("numeric", 1 / 0);
             case "N":
-              return read4(), literal("aN"), newToken("numeric", NaN);
+              return read4(), literal2("aN"), newToken("numeric", NaN);
             case '"':
             case "'":
               return doubleQuote = '"' === read4(), buffer = "", void (lexState = "string");
@@ -28517,9 +28517,9 @@ ${trace}`);
             case "9":
               return buffer = read4(), void (lexState = "decimalInteger");
             case "I":
-              return read4(), literal("nfinity"), newToken("numeric", sign2 * (1 / 0));
+              return read4(), literal2("nfinity"), newToken("numeric", sign2 * (1 / 0));
             case "N":
-              return read4(), literal("aN"), newToken("numeric", NaN);
+              return read4(), literal2("aN"), newToken("numeric", NaN);
           }
           throw invalidChar(read4());
         }, zero() {
@@ -28698,7 +28698,7 @@ ${trace}`);
         function newToken(type2, value2) {
           return { type: type2, value: value2, line, column };
         }
-        function literal(s) {
+        function literal2(s) {
           for (const c2 of s) {
             if (peek() !== c2) throw invalidChar(read4());
             read4();
@@ -29257,12 +29257,12 @@ ${trace}`);
         }, Parser.tokenizer = function(input, options) {
           return new this(options, input);
         }, Object.defineProperties(Parser.prototype, prototypeAccessors);
-        var pp$9 = Parser.prototype, literal = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/;
+        var pp$9 = Parser.prototype, literal2 = /^(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/;
         pp$9.strictDirective = function(start) {
           if (this.options.ecmaVersion < 5) return false;
           for (; ; ) {
             skipWhiteSpace.lastIndex = start, start += skipWhiteSpace.exec(this.input)[0].length;
-            var match4 = literal.exec(this.input.slice(start));
+            var match4 = literal2.exec(this.input.slice(start));
             if (!match4) return false;
             if ("use strict" === (match4[1] || match4[2])) {
               skipWhiteSpace.lastIndex = start + match4[0].length;
@@ -58487,9 +58487,9 @@ ${indent2}`) + "'";
         return quotedString(value2, ctx);
       }
       const indent2 = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value2) ? "  " : "");
-      const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type2 === Scalar.Scalar.BLOCK_FOLDED ? false : type2 === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value2, lineWidth, indent2.length);
+      const literal2 = blockQuote === "literal" ? true : blockQuote === "folded" || type2 === Scalar.Scalar.BLOCK_FOLDED ? false : type2 === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value2, lineWidth, indent2.length);
       if (!value2)
-        return literal ? "|\n" : ">\n";
+        return literal2 ? "|\n" : ">\n";
       let chomp;
       let endStart;
       for (endStart = value2.length; endStart > 0; --endStart) {
@@ -58538,7 +58538,7 @@ ${indent2}`) + "'";
         if (onComment)
           onComment();
       }
-      if (!literal) {
+      if (!literal2) {
         const foldedValue = value2.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent2}`);
         let literalFallback = false;
         const foldOptions = getFoldOptions(ctx, true);
@@ -90823,9 +90823,9 @@ ${lanes.join("\n")}
               tokenValue = "" + parseInt(tokenValue, 8);
               tokenFlags |= 32;
               const withMinus = token === 41;
-              const literal = (withMinus ? "-" : "") + "0o" + (+tokenValue).toString(8);
+              const literal2 = (withMinus ? "-" : "") + "0o" + (+tokenValue).toString(8);
               if (withMinus) start2--;
-              error22(Diagnostics.Octal_literals_are_not_allowed_Use_the_syntax_0, start2, pos - start2, literal);
+              error22(Diagnostics.Octal_literals_are_not_allowed_Use_the_syntax_0, start2, pos - start2, literal2);
               return 9;
             }
           } else {
@@ -105332,18 +105332,18 @@ ${lanes.join("\n")}
         function updateIndexSignature(node, modifiers, parameters, type2) {
           return node.parameters !== parameters || node.type !== type2 || node.modifiers !== modifiers ? finishUpdateBaseSignatureDeclaration(createIndexSignature(modifiers, parameters, type2), node) : node;
         }
-        function createTemplateLiteralTypeSpan(type2, literal) {
+        function createTemplateLiteralTypeSpan(type2, literal2) {
           const node = createBaseNode(
             204
             /* TemplateLiteralTypeSpan */
           );
           node.type = type2;
-          node.literal = literal;
+          node.literal = literal2;
           node.transformFlags = 1;
           return node;
         }
-        function updateTemplateLiteralTypeSpan(node, type2, literal) {
-          return node.type !== type2 || node.literal !== literal ? update(createTemplateLiteralTypeSpan(type2, literal), node) : node;
+        function updateTemplateLiteralTypeSpan(node, type2, literal2) {
+          return node.type !== type2 || node.literal !== literal2 ? update(createTemplateLiteralTypeSpan(type2, literal2), node) : node;
         }
         function createKeywordTypeNode(kind) {
           return createToken(kind);
@@ -105673,17 +105673,17 @@ ${lanes.join("\n")}
         function updateMappedTypeNode(node, readonlyToken, typeParameter, nameType, questionToken, type2, members) {
           return node.readonlyToken !== readonlyToken || node.typeParameter !== typeParameter || node.nameType !== nameType || node.questionToken !== questionToken || node.type !== type2 || node.members !== members ? update(createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type2, members), node) : node;
         }
-        function createLiteralTypeNode(literal) {
+        function createLiteralTypeNode(literal2) {
           const node = createBaseNode(
             201
             /* LiteralType */
           );
-          node.literal = literal;
+          node.literal = literal2;
           node.transformFlags = 1;
           return node;
         }
-        function updateLiteralTypeNode(node, literal) {
-          return node.literal !== literal ? update(createLiteralTypeNode(literal), node) : node;
+        function updateLiteralTypeNode(node, literal2) {
+          return node.literal !== literal2 ? update(createLiteralTypeNode(literal2), node) : node;
         }
         function createObjectBindingPattern(elements) {
           const node = createBaseNode(
@@ -106416,18 +106416,18 @@ ${lanes.join("\n")}
         function updateMetaProperty(node, name2) {
           return node.name !== name2 ? update(createMetaProperty(node.keywordToken, name2), node) : node;
         }
-        function createTemplateSpan(expression, literal) {
+        function createTemplateSpan(expression, literal2) {
           const node = createBaseNode(
             239
             /* TemplateSpan */
           );
           node.expression = expression;
-          node.literal = literal;
+          node.literal = literal2;
           node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.literal) | 1024;
           return node;
         }
-        function updateTemplateSpan(node, expression, literal) {
-          return node.expression !== expression || node.literal !== literal ? update(createTemplateSpan(expression, literal), node) : node;
+        function updateTemplateSpan(node, expression, literal2) {
+          return node.expression !== expression || node.literal !== literal2 ? update(createTemplateSpan(expression, literal2), node) : node;
         }
         function createSemicolonClassElement() {
           const node = createBaseNode(
@@ -120656,12 +120656,12 @@ ${lanes.join("\n")}
                   }
                 }
                 if (children) {
-                  const literal = finishNode(factory2.createJSDocTypeLiteral(
+                  const literal2 = finishNode(factory2.createJSDocTypeLiteral(
                     children,
                     typeExpression.type.kind === 188
                     /* ArrayType */
                   ), pos);
-                  return finishNode(factory2.createJSDocTypeExpression(literal), pos);
+                  return finishNode(factory2.createJSDocTypeExpression(literal2), pos);
                 }
               }
             }
@@ -142139,10 +142139,10 @@ ${lanes.join("\n")}
           if (parentAccess && canHaveFlowNode(parentAccess) && parentAccess.flowNode) {
             const propName = getDestructuringPropertyName(node);
             if (propName) {
-              const literal = setTextRange(parseNodeFactory.createStringLiteral(propName), node);
+              const literal2 = setTextRange(parseNodeFactory.createStringLiteral(propName), node);
               const lhsExpr = isLeftHandSideExpression(parentAccess) ? parentAccess : parseNodeFactory.createParenthesizedExpression(parentAccess);
-              const result = setTextRange(parseNodeFactory.createElementAccessExpression(lhsExpr, literal), node);
-              setParent(literal, result);
+              const result = setTextRange(parseNodeFactory.createElementAccessExpression(lhsExpr, literal2), node);
+              setParent(literal2, result);
               setParent(result, node);
               if (lhsExpr !== parentAccess) {
                 setParent(lhsExpr, result);
@@ -158129,13 +158129,13 @@ ${lanes.join("\n")}
             }
             return type2;
           }
-          function narrowTypeByTypeof(type2, typeOfExpr, operator, literal, assumeTrue) {
+          function narrowTypeByTypeof(type2, typeOfExpr, operator, literal2, assumeTrue) {
             if (operator === 36 || operator === 38) {
               assumeTrue = !assumeTrue;
             }
             const target = getReferenceCandidate(typeOfExpr.expression);
             if (!isMatchingReference(reference, target)) {
-              if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
+              if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal2.text !== "undefined")) {
                 type2 = getAdjustedTypeWithFacts(
                   type2,
                   2097152
@@ -158144,16 +158144,16 @@ ${lanes.join("\n")}
               }
               const propertyAccess = getDiscriminantPropertyAccess(target, type2);
               if (propertyAccess) {
-                return narrowTypeByDiscriminant(type2, propertyAccess, (t) => narrowTypeByLiteralExpression(t, literal, assumeTrue));
+                return narrowTypeByDiscriminant(type2, propertyAccess, (t) => narrowTypeByLiteralExpression(t, literal2, assumeTrue));
               }
               return type2;
             }
-            return narrowTypeByLiteralExpression(type2, literal, assumeTrue);
+            return narrowTypeByLiteralExpression(type2, literal2, assumeTrue);
           }
-          function narrowTypeByLiteralExpression(type2, literal, assumeTrue) {
-            return assumeTrue ? narrowTypeByTypeName(type2, literal.text) : getAdjustedTypeWithFacts(
+          function narrowTypeByLiteralExpression(type2, literal2, assumeTrue) {
+            return assumeTrue ? narrowTypeByTypeName(type2, literal2.text) : getAdjustedTypeWithFacts(
               type2,
-              typeofNEFacts.get(literal.text) || 32768
+              typeofNEFacts.get(literal2.text) || 32768
               /* TypeofNEHostObject */
             );
           }
@@ -159839,19 +159839,19 @@ ${lanes.join("\n")}
           });
         }
         function getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType) {
-          let literal = containingLiteral;
+          let literal2 = containingLiteral;
           let type2 = contextualType;
           while (type2) {
             const thisType = getThisTypeFromContextualType(type2);
             if (thisType) {
               return thisType;
             }
-            if (literal.parent.kind !== 303) {
+            if (literal2.parent.kind !== 303) {
               break;
             }
-            literal = literal.parent.parent;
+            literal2 = literal2.parent.parent;
             type2 = getApparentTypeOfContextualType(
-              literal,
+              literal2,
               /*contextFlags*/
               void 0
             );
@@ -193673,8 +193673,8 @@ ${lanes.join("\n")}
           }
           if (node.kind === 11) {
             const singleQuote = node.singleQuote !== void 0 ? node.singleQuote : !isStringDoubleQuoted(node, currentSourceFile);
-            const literal = factory2.createStringLiteral(tryDecodeEntities(node.text) || node.text, singleQuote);
-            return setTextRange(literal, node);
+            const literal2 = factory2.createStringLiteral(tryDecodeEntities(node.text) || node.text, singleQuote);
+            return setTextRange(literal2, node);
           }
           if (node.kind === 294) {
             if (node.expression === void 0) {
@@ -199397,9 +199397,9 @@ ${lanes.join("\n")}
           return factory2.createOmittedExpression();
         }
         function createInstruction(instruction) {
-          const literal = factory2.createNumericLiteral(instruction);
-          addSyntheticTrailingComment(literal, 3, getInstructionName(instruction));
-          return literal;
+          const literal2 = factory2.createNumericLiteral(instruction);
+          addSyntheticTrailingComment(literal2, 3, getInstructionName(instruction));
+          return literal2;
         }
         function createInlineBreak(label, location2) {
           Debug.assertLessThan(0, label, "Invalid label");
@@ -212901,8 +212901,8 @@ ${lanes.join("\n")}
         resolvedModule: void 0,
         resolvedTypeReferenceDirective: void 0
       };
-      function getModuleResolutionName(literal) {
-        return literal.text;
+      function getModuleResolutionName(literal2) {
+        return literal2.text;
       }
       var moduleResolutionNameAndModeGetter = {
         getName: getModuleResolutionName,
@@ -224440,10 +224440,10 @@ ${lanes.join("\n")}
                 return resolver.serializeExistingTypeNode(context, node);
               }
               const specifier = rewriteModuleSpecifier2(node, node.argument.literal);
-              const literal = specifier === node.argument.literal ? reuseNode(context, node.argument.literal) : specifier;
+              const literal2 = specifier === node.argument.literal ? reuseNode(context, node.argument.literal) : specifier;
               return factory.updateImportTypeNode(
                 node,
-                literal === node.argument.literal ? reuseNode(context, node.argument) : factory.createLiteralTypeNode(literal),
+                literal2 === node.argument.literal ? reuseNode(context, node.argument) : factory.createLiteralTypeNode(literal2),
                 visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes),
                 visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName),
                 visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
@@ -224486,9 +224486,9 @@ ${lanes.join("\n")}
                 return factory.updateComputedPropertyName(node, result);
               } else {
                 const computedPropertyNameType = resolver.serializeTypeOfExpression(context, node.expression);
-                let literal;
+                let literal2;
                 if (isLiteralTypeNode(computedPropertyNameType)) {
-                  literal = computedPropertyNameType.literal;
+                  literal2 = computedPropertyNameType.literal;
                 } else {
                   const evaluated = resolver.evaluateEntityNameExpression(node.expression);
                   const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral(
@@ -224506,15 +224506,15 @@ ${lanes.join("\n")}
                     }
                     return node;
                   }
-                  literal = literalNode;
+                  literal2 = literalNode;
                 }
-                if (literal.kind === 11 && isIdentifierText(literal.text, getEmitScriptTarget(options))) {
-                  return factory.createIdentifier(literal.text);
+                if (literal2.kind === 11 && isIdentifierText(literal2.text, getEmitScriptTarget(options))) {
+                  return factory.createIdentifier(literal2.text);
                 }
-                if (literal.kind === 9 && !literal.text.startsWith("-")) {
-                  return literal;
+                if (literal2.kind === 9 && !literal2.text.startsWith("-")) {
+                  return literal2;
                 }
-                return factory.updateComputedPropertyName(node, literal);
+                return factory.updateComputedPropertyName(node, literal2);
               }
             }
             if (isTypePredicateNode(node)) {
@@ -255076,7 +255076,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const caseClause = findAncestor(contextToken, isCaseClause);
         if (caseClause && (isCaseKeyword(contextToken) || isNodeDescendantOf(contextToken, caseClause.expression))) {
           const tracker = newCaseClauseTracker(checker, caseClause.parent.clauses);
-          literals = literals.filter((literal) => !tracker.hasValue(literal));
+          literals = literals.filter((literal2) => !tracker.hasValue(literal2));
           symbols.forEach((symbol, i) => {
             if (symbol.valueDeclaration && isEnumMember(symbol.valueDeclaration)) {
               const value2 = checker.getConstantValue(symbol.valueDeclaration);
@@ -255153,8 +255153,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             );
           }
         }
-        for (const literal of literals) {
-          const literalEntry = createCompletionEntryForLiteral(sourceFile, preferences, literal);
+        for (const literal2 of literals) {
+          const literalEntry = createCompletionEntryForLiteral(sourceFile, preferences, literal2);
           uniqueNames.add(literalEntry.name);
           insertSorted(
             entries,
@@ -255283,16 +255283,16 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             const indexExpression = typeNodeToExpression(typeNode.indexType, languageVersion, quotePreference);
             return objectExpression && indexExpression && factory.createElementAccessExpression(objectExpression, indexExpression);
           case 201:
-            const literal = typeNode.literal;
-            switch (literal.kind) {
+            const literal2 = typeNode.literal;
+            switch (literal2.kind) {
               case 11:
                 return factory.createStringLiteral(
-                  literal.text,
+                  literal2.text,
                   quotePreference === 0
                   /* Single */
                 );
               case 9:
-                return factory.createNumericLiteral(literal.text, literal.numericLiteralFlags);
+                return factory.createNumericLiteral(literal2.text, literal2.numericLiteralFlags);
             }
             return void 0;
           case 196:
@@ -255395,12 +255395,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
         });
       }
-      function completionNameForLiteral(sourceFile, preferences, literal) {
-        return typeof literal === "object" ? pseudoBigIntToString(literal) + "n" : isString2(literal) ? quote(sourceFile, preferences, literal) : JSON.stringify(literal);
+      function completionNameForLiteral(sourceFile, preferences, literal2) {
+        return typeof literal2 === "object" ? pseudoBigIntToString(literal2) + "n" : isString2(literal2) ? quote(sourceFile, preferences, literal2) : JSON.stringify(literal2);
       }
-      function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
+      function createCompletionEntryForLiteral(sourceFile, preferences, literal2) {
         return {
-          name: completionNameForLiteral(sourceFile, preferences, literal),
+          name: completionNameForLiteral(sourceFile, preferences, literal2),
           kind: "string",
           kindModifiers: "",
           sortText: SortText.LocationPriority,
@@ -256311,8 +256311,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           return { type: "request", request: completionData };
         }
         const { symbols, literals, location: location2, completionKind, symbolToOriginInfoMap, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation } = completionData;
-        const literal = find2(literals, (l) => completionNameForLiteral(sourceFile, preferences, l) === entryId.name);
-        if (literal !== void 0) return { type: "literal", literal };
+        const literal2 = find2(literals, (l) => completionNameForLiteral(sourceFile, preferences, l) === entryId.name);
+        if (literal2 !== void 0) return { type: "literal", literal: literal2 };
         return firstDefined(symbols, (symbol, index2) => {
           const origin = symbolToOriginInfoMap[index2];
           const info = getCompletionEntryDisplayNameForSymbol(symbol, getEmitScriptTarget(compilerOptions), origin, completionKind, completionData.isJsxIdentifierExpected);
@@ -256356,11 +256356,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             return createCompletionDetailsForSymbol(symbol, symbolName2, typeChecker, sourceFile, location2, cancellationToken, codeActions, sourceDisplay);
           }
           case "literal": {
-            const { literal } = symbolCompletion;
+            const { literal: literal2 } = symbolCompletion;
             return createSimpleDetails(
-              completionNameForLiteral(sourceFile, preferences, literal),
+              completionNameForLiteral(sourceFile, preferences, literal2),
               "string",
-              typeof literal === "string" ? 8 : 7
+              typeof literal2 === "string" ? 8 : 7
               /* numericLiteral */
             );
           }
@@ -258899,7 +258899,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             if (!contextualTypes) {
               return;
             }
-            const literals = contextualTypes.types.filter((literal) => !tracker.hasValue(literal.value));
+            const literals = contextualTypes.types.filter((literal2) => !tracker.hasValue(literal2.value));
             return { kind: 2, types: literals, isNewIdentifier: false };
           case 276:
           case 281:
@@ -315481,6 +315481,24 @@ var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
     return payload;
   };
 });
+var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.values = new Set(def.values);
+  inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? o.toString() : String(o)).join("|")})$`);
+  inst._zod.parse = (payload, _ctx) => {
+    const input = payload.value;
+    if (inst._zod.values.has(input)) {
+      return payload;
+    }
+    payload.issues.push({
+      code: "invalid_value",
+      values: def.values,
+      input,
+      inst
+    });
+    return payload;
+  };
+});
 var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, _ctx) => {
@@ -316793,6 +316811,26 @@ function _enum(values, params) {
     ...util_exports.normalizeParams(params)
   });
 }
+var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
+  $ZodLiteral.init(inst, def);
+  ZodType.init(inst, def);
+  inst.values = new Set(def.values);
+  Object.defineProperty(inst, "value", {
+    get() {
+      if (def.values.length > 1) {
+        throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+      }
+      return def.values[0];
+    }
+  });
+});
+function literal(value2, params) {
+  return new ZodLiteral({
+    type: "literal",
+    values: Array.isArray(value2) ? value2 : [value2],
+    ...util_exports.normalizeParams(params)
+  });
+}
 var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
@@ -317054,10 +317092,10 @@ var RegistryConfigSchema = object({
 var ColorConfigSchema = SingleThemeColorConfigSchema.or(
   MultiThemeColorConfigSchema
 ).describe("Colors used for various workspace elements");
-var ColorConfigMapSchema = union([
-  object({ base: ColorConfigSchema }),
-  record(string2(), ColorConfigSchema)
-]);
+var ColorConfigMapSchema = record(
+  union([literal("base"), string2()]),
+  ColorConfigSchema
+);
 var ExtendsItemSchema = string2().trim().describe(
   "The path to a base config file to use as a configuration preset file. Documentation can be found at https://github.com/unjs/c12#extending-configuration."
 );
@@ -373703,7 +373741,7 @@ function expand4(template2, context) {
   var operators2 = ["+", "#", ".", "/", ";", "?", "&"];
   template2 = template2.replace(
     /\{([^\{\}]+)\}|([^\{\}]+)/g,
-    function(_, expression, literal) {
+    function(_, expression, literal2) {
       if (expression) {
         let operator = "";
         const values = [];
@@ -373727,7 +373765,7 @@ function expand4(template2, context) {
           return values.join(",");
         }
       } else {
-        return encodeReserved(literal);
+        return encodeReserved(literal2);
       }
     }
   );