repoburg 1.1.0 → 1.1.1

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js

@@ -0,0 +1,540 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+// Truthiness utilities
+// #region
+const isTruthyLiteral = (type) => tsutils.isTrueLiteralType(type) ||
+    //  || type.
+    (type.isLiteral() && !!type.value);
+const isPossiblyFalsy = (type) => tsutils
+    .unionTypeParts(type)
+    // Intersections like `string & {}` can also be possibly falsy,
+    // requiring us to look into the intersection.
+    .flatMap(type => tsutils.intersectionTypeParts(type))
+    // PossiblyFalsy flag includes literal values, so exclude ones that
+    // are definitely truthy
+    .filter(t => !isTruthyLiteral(t))
+    .some(type => (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.PossiblyFalsy));
+const isPossiblyTruthy = (type) => tsutils
+    .unionTypeParts(type)
+    .map(type => tsutils.intersectionTypeParts(type))
+    .some(intersectionParts => 
+// It is possible to define intersections that are always falsy,
+// like `"" & { __brand: string }`.
+intersectionParts.every(type => !tsutils.isFalsyType(type)));
+// Nullish utilities
+const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
+const isNullishType = (type) => (0, util_1.isTypeFlagSet)(type, nullishFlag);
+const isPossiblyNullish = (type) => tsutils.unionTypeParts(type).some(isNullishType);
+const isAlwaysNullish = (type) => tsutils.unionTypeParts(type).every(isNullishType);
+// isLiteralType only covers numbers and strings, this is a more exhaustive check.
+const isLiteral = (type) => tsutils.isBooleanLiteralType(type) ||
+    type.flags === ts.TypeFlags.Undefined ||
+    type.flags === ts.TypeFlags.Null ||
+    type.flags === ts.TypeFlags.Void ||
+    type.isLiteral();
+exports.default = (0, util_1.createRule)({
+    name: 'no-unnecessary-condition',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow conditionals where the type is always truthy or always falsy',
+            recommended: 'strict',
+            requiresTypeChecking: true,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowConstantLoopConditions: {
+                        description: 'Whether to ignore constant loop conditions, such as `while (true)`.',
+                        type: 'boolean',
+                    },
+                    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+                        description: 'Whether to not error when running with a tsconfig that has strictNullChecks turned.',
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        fixable: 'code',
+        messages: {
+            alwaysTruthy: 'Unnecessary conditional, value is always truthy.',
+            alwaysFalsy: 'Unnecessary conditional, value is always falsy.',
+            alwaysTruthyFunc: 'This callback should return a conditional, but return is always truthy.',
+            alwaysFalsyFunc: 'This callback should return a conditional, but return is always falsy.',
+            neverNullish: 'Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.',
+            alwaysNullish: 'Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.',
+            literalBooleanExpression: 'Unnecessary conditional, both sides of the expression are literal values.',
+            noOverlapBooleanExpression: 'Unnecessary conditional, the types have no overlap.',
+            never: 'Unnecessary conditional, value is `never`.',
+            neverOptionalChain: 'Unnecessary optional chain on a non-nullish value.',
+            noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+        },
+    },
+    defaultOptions: [
+        {
+            allowConstantLoopConditions: false,
+            allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+        },
+    ],
+    create(context, [{ allowConstantLoopConditions, allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing, },]) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        const sourceCode = (0, eslint_utils_1.getSourceCode)(context);
+        const compilerOptions = services.program.getCompilerOptions();
+        const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks');
+        if (!isStrictNullChecks &&
+            allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) {
+            context.report({
+                loc: {
+                    start: { line: 0, column: 0 },
+                    end: { line: 0, column: 0 },
+                },
+                messageId: 'noStrictNullCheck',
+            });
+        }
+        function nodeIsArrayType(node) {
+            const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            return checker.isArrayType(nodeType);
+        }
+        function nodeIsTupleType(node) {
+            const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            return checker.isTupleType(nodeType);
+        }
+        function isArrayIndexExpression(node) {
+            return (
+            // Is an index signature
+            node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.computed &&
+                // ...into an array type
+                (nodeIsArrayType(node.object) ||
+                    // ... or a tuple type
+                    (nodeIsTupleType(node.object) &&
+                        // Exception: literal index into a tuple - will have a sound type
+                        node.property.type !== utils_1.AST_NODE_TYPES.Literal)));
+        }
+        function isNullableMemberExpression(node) {
+            const objectType = services.getTypeAtLocation(node.object);
+            if (node.computed) {
+                const propertyType = services.getTypeAtLocation(node.property);
+                return isNullablePropertyType(objectType, propertyType);
+            }
+            const property = node.property;
+            if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const propertyType = objectType.getProperty(property.name);
+                if (propertyType &&
+                    tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        /**
+         * Checks if a conditional node is necessary:
+         * if the type of the node is always true or always false, it's not necessary.
+         */
+        function checkNode(node, isUnaryNotArgument = false) {
+            // Check if the node is Unary Negation expression and handle it
+            if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                node.operator === '!') {
+                return checkNode(node.argument, true);
+            }
+            // Since typescript array index signature types don't represent the
+            //  possibility of out-of-bounds access, if we're indexing into an array
+            //  just skip the check, to avoid false positives
+            if (isArrayIndexExpression(node)) {
+                return;
+            }
+            // When checking logical expressions, only check the right side
+            //  as the left side has been checked by checkLogicalExpressionForUnnecessaryConditionals
+            //
+            // Unless the node is nullish coalescing, as it's common to use patterns like `nullBool ?? true` to to strict
+            //  boolean checks if we inspect the right here, it'll usually be a constant condition on purpose.
+            // In this case it's better to inspect the type of the expression as a whole.
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                node.operator !== '??') {
+                return checkNode(node.right);
+            }
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            // Conditional is always necessary if it involves:
+            //    `any` or `unknown` or a naked type variable
+            if (tsutils
+                .unionTypeParts(type)
+                .some(part => (0, util_1.isTypeAnyType)(part) ||
+                (0, util_1.isTypeUnknownType)(part) ||
+                (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.TypeVariable))) {
+                return;
+            }
+            let messageId = null;
+            if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Never)) {
+                messageId = 'never';
+            }
+            else if (!isPossiblyTruthy(type)) {
+                messageId = !isUnaryNotArgument ? 'alwaysFalsy' : 'alwaysTruthy';
+            }
+            else if (!isPossiblyFalsy(type)) {
+                messageId = !isUnaryNotArgument ? 'alwaysTruthy' : 'alwaysFalsy';
+            }
+            if (messageId) {
+                context.report({ node, messageId });
+            }
+        }
+        function checkNodeForNullish(node) {
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            // Conditional is always necessary if it involves `any`, `unknown` or a naked type parameter
+            if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Any |
+                ts.TypeFlags.Unknown |
+                ts.TypeFlags.TypeParameter |
+                ts.TypeFlags.TypeVariable)) {
+                return;
+            }
+            let messageId = null;
+            if ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Never)) {
+                messageId = 'never';
+            }
+            else if (!isPossiblyNullish(type) &&
+                !(node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    isNullableMemberExpression(node))) {
+                // Since typescript array index signature types don't represent the
+                //  possibility of out-of-bounds access, if we're indexing into an array
+                //  just skip the check, to avoid false positives
+                if (!isArrayIndexExpression(node) &&
+                    !(node.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                        node.expression.type !== utils_1.AST_NODE_TYPES.TSNonNullExpression &&
+                        optionChainContainsOptionArrayIndex(node.expression))) {
+                    messageId = 'neverNullish';
+                }
+            }
+            else if (isAlwaysNullish(type)) {
+                messageId = 'alwaysNullish';
+            }
+            if (messageId) {
+                context.report({ node, messageId });
+            }
+        }
+        /**
+         * Checks that a binary expression is necessarily conditional, reports otherwise.
+         * If both sides of the binary expression are literal values, it's not a necessary condition.
+         *
+         * NOTE: It's also unnecessary if the types that don't overlap at all
+         *    but that case is handled by the Typescript compiler itself.
+         *    Known exceptions:
+         *      - https://github.com/microsoft/TypeScript/issues/32627
+         *      - https://github.com/microsoft/TypeScript/issues/37160 (handled)
+         */
+        const BOOL_OPERATORS = new Set([
+            '<',
+            '>',
+            '<=',
+            '>=',
+            '==',
+            '===',
+            '!=',
+            '!==',
+        ]);
+        function checkIfBinaryExpressionIsNecessaryConditional(node) {
+            if (!BOOL_OPERATORS.has(node.operator)) {
+                return;
+            }
+            const leftType = (0, util_1.getConstrainedTypeAtLocation)(services, node.left);
+            const rightType = (0, util_1.getConstrainedTypeAtLocation)(services, node.right);
+            if (isLiteral(leftType) && isLiteral(rightType)) {
+                context.report({ node, messageId: 'literalBooleanExpression' });
+                return;
+            }
+            // Workaround for https://github.com/microsoft/TypeScript/issues/37160
+            if (isStrictNullChecks) {
+                const UNDEFINED = ts.TypeFlags.Undefined;
+                const NULL = ts.TypeFlags.Null;
+                const VOID = ts.TypeFlags.Void;
+                const isComparable = (type, flag) => {
+                    // Allow comparison to `any`, `unknown` or a naked type parameter.
+                    flag |=
+                        ts.TypeFlags.Any |
+                            ts.TypeFlags.Unknown |
+                            ts.TypeFlags.TypeParameter |
+                            ts.TypeFlags.TypeVariable;
+                    // Allow loose comparison to nullish values.
+                    if (node.operator === '==' || node.operator === '!=') {
+                        flag |= NULL | UNDEFINED | VOID;
+                    }
+                    return (0, util_1.isTypeFlagSet)(type, flag);
+                };
+                if ((leftType.flags === UNDEFINED &&
+                    !isComparable(rightType, UNDEFINED | VOID)) ||
+                    (rightType.flags === UNDEFINED &&
+                        !isComparable(leftType, UNDEFINED | VOID)) ||
+                    (leftType.flags === NULL && !isComparable(rightType, NULL)) ||
+                    (rightType.flags === NULL && !isComparable(leftType, NULL))) {
+                    context.report({ node, messageId: 'noOverlapBooleanExpression' });
+                    return;
+                }
+            }
+        }
+        /**
+         * Checks that a logical expression contains a boolean, reports otherwise.
+         */
+        function checkLogicalExpressionForUnnecessaryConditionals(node) {
+            if (node.operator === '??') {
+                checkNodeForNullish(node.left);
+                return;
+            }
+            // Only checks the left side, since the right side might not be "conditional" at all.
+            // The right side will be checked if the LogicalExpression is used in a conditional context
+            checkNode(node.left);
+        }
+        /**
+         * Checks that a testable expression of a loop is necessarily conditional, reports otherwise.
+         */
+        function checkIfLoopIsNecessaryConditional(node) {
+            if (node.test == null) {
+                // e.g. `for(;;)`
+                return;
+            }
+            /**
+             * Allow:
+             *   while (true) {}
+             *   for (;true;) {}
+             *   do {} while (true)
+             */
+            if (allowConstantLoopConditions &&
+                tsutils.isTrueLiteralType((0, util_1.getConstrainedTypeAtLocation)(services, node.test))) {
+                return;
+            }
+            checkNode(node.test);
+        }
+        const ARRAY_PREDICATE_FUNCTIONS = new Set([
+            'filter',
+            'find',
+            'some',
+            'every',
+        ]);
+        function isArrayPredicateFunction(node) {
+            const { callee } = node;
+            return (
+            // looks like `something.filter` or `something.find`
+            callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                ARRAY_PREDICATE_FUNCTIONS.has(callee.property.name) &&
+                // and the left-hand side is an array, according to the types
+                (nodeIsArrayType(callee.object) || nodeIsTupleType(callee.object)));
+        }
+        function checkCallExpression(node) {
+            // If this is something like arr.filter(x => /*condition*/), check `condition`
+            if (isArrayPredicateFunction(node) && node.arguments.length) {
+                const callback = node.arguments[0];
+                // Inline defined functions
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    // Two special cases, where we can directly check the node that's returned:
+                    // () => something
+                    if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                        return checkNode(callback.body);
+                    }
+                    // () => { return something; }
+                    const callbackBody = callback.body.body;
+                    if (callbackBody.length === 1 &&
+                        callbackBody[0].type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                        callbackBody[0].argument) {
+                        return checkNode(callbackBody[0].argument);
+                    }
+                    // Potential enhancement: could use code-path analysis to check
+                    //   any function with a single return statement
+                    // (Value to complexity ratio is dubious however)
+                }
+                // Otherwise just do type analysis on the function as a whole.
+                const returnTypes = tsutils
+                    .getCallSignaturesOfType((0, util_1.getConstrainedTypeAtLocation)(services, callback))
+                    .map(sig => sig.getReturnType());
+                /* istanbul ignore if */ if (returnTypes.length === 0) {
+                    // Not a callable function
+                    return;
+                }
+                // Predicate is always necessary if it involves `any` or `unknown`
+                if (returnTypes.some(t => (0, util_1.isTypeAnyType)(t) || (0, util_1.isTypeUnknownType)(t))) {
+                    return;
+                }
+                if (!returnTypes.some(isPossiblyFalsy)) {
+                    return context.report({
+                        node: callback,
+                        messageId: 'alwaysTruthyFunc',
+                    });
+                }
+                if (!returnTypes.some(isPossiblyTruthy)) {
+                    return context.report({
+                        node: callback,
+                        messageId: 'alwaysFalsyFunc',
+                    });
+                }
+            }
+        }
+        // Recursively searches an optional chain for an array index expression
+        //  Has to search the entire chain, because an array index will "infect" the rest of the types
+        //  Example:
+        //  ```
+        //  [{x: {y: "z"} }][n] // type is {x: {y: "z"}}
+        //    ?.x // type is {y: "z"}
+        //    ?.y // This access is considered "unnecessary" according to the types
+        //  ```
+        function optionChainContainsOptionArrayIndex(node) {
+            const lhsNode = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node.object;
+            if (node.optional && isArrayIndexExpression(lhsNode)) {
+                return true;
+            }
+            if (lhsNode.type === utils_1.AST_NODE_TYPES.MemberExpression ||
+                lhsNode.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                return optionChainContainsOptionArrayIndex(lhsNode);
+            }
+            return false;
+        }
+        function isNullablePropertyType(objType, propertyType) {
+            if (propertyType.isUnion()) {
+                return propertyType.types.some(type => isNullablePropertyType(objType, type));
+            }
+            if (propertyType.isNumberLiteral() || propertyType.isStringLiteral()) {
+                const propType = (0, util_1.getTypeOfPropertyOfName)(checker, objType, propertyType.value.toString());
+                if (propType) {
+                    return (0, util_1.isNullableType)(propType);
+                }
+            }
+            const typeName = (0, util_1.getTypeName)(checker, propertyType);
+            return !!checker
+                .getIndexInfosOfType(objType)
+                .find(info => (0, util_1.getTypeName)(checker, info.keyType) === typeName);
+        }
+        // Checks whether a member expression is nullable or not regardless of it's previous node.
+        //  Example:
+        //  ```
+        //  // 'bar' is nullable if 'foo' is null.
+        //  // but this function checks regardless of 'foo' type, so returns 'true'.
+        //  declare const foo: { bar : { baz: string } } | null
+        //  foo?.bar;
+        //  ```
+        function isMemberExpressionNullableOriginFromObject(node) {
+            const prevType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object);
+            const property = node.property;
+            if (prevType.isUnion() && (0, util_1.isIdentifier)(property)) {
+                const isOwnNullable = prevType.types.some(type => {
+                    if (node.computed) {
+                        const propertyType = (0, util_1.getConstrainedTypeAtLocation)(services, node.property);
+                        return isNullablePropertyType(type, propertyType);
+                    }
+                    const propType = (0, util_1.getTypeOfPropertyOfName)(checker, type, property.name);
+                    if (propType) {
+                        return (0, util_1.isNullableType)(propType);
+                    }
+                    return !!checker.getIndexInfoOfType(type, ts.IndexKind.String);
+                });
+                return !isOwnNullable && (0, util_1.isNullableType)(prevType);
+            }
+            return false;
+        }
+        function isCallExpressionNullableOriginFromCallee(node) {
+            const prevType = (0, util_1.getConstrainedTypeAtLocation)(services, node.callee);
+            if (prevType.isUnion()) {
+                const isOwnNullable = prevType.types.some(type => {
+                    const signatures = type.getCallSignatures();
+                    return signatures.some(sig => (0, util_1.isNullableType)(sig.getReturnType(), { allowUndefined: true }));
+                });
+                return (!isOwnNullable && (0, util_1.isNullableType)(prevType, { allowUndefined: true }));
+            }
+            return false;
+        }
+        function isOptionableExpression(node) {
+            const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
+            const isOwnNullable = node.type === utils_1.AST_NODE_TYPES.MemberExpression
+                ? !isMemberExpressionNullableOriginFromObject(node)
+                : node.type === utils_1.AST_NODE_TYPES.CallExpression
+                    ? !isCallExpressionNullableOriginFromCallee(node)
+                    : true;
+            const possiblyVoid = (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Void);
+            return ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown) ||
+                (isOwnNullable && ((0, util_1.isNullableType)(type) || possiblyVoid)));
+        }
+        function checkOptionalChain(node, beforeOperator, fix) {
+            // We only care if this step in the chain is optional. If just descend
+            // from an optional chain, then that's fine.
+            if (!node.optional) {
+                return;
+            }
+            // Since typescript array index signature types don't represent the
+            //  possibility of out-of-bounds access, if we're indexing into an array
+            //  just skip the check, to avoid false positives
+            if (optionChainContainsOptionArrayIndex(node)) {
+                return;
+            }
+            const nodeToCheck = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node.object;
+            if (isOptionableExpression(nodeToCheck)) {
+                return;
+            }
+            const questionDotOperator = (0, util_1.nullThrows)(sourceCode.getTokenAfter(beforeOperator, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '?.'), util_1.NullThrowsReasons.MissingToken('operator', node.type));
+            context.report({
+                node,
+                loc: questionDotOperator.loc,
+                messageId: 'neverOptionalChain',
+                fix(fixer) {
+                    return fixer.replaceText(questionDotOperator, fix);
+                },
+            });
+        }
+        function checkOptionalMemberExpression(node) {
+            checkOptionalChain(node, node.object, node.computed ? '' : '.');
+        }
+        function checkOptionalCallExpression(node) {
+            checkOptionalChain(node, node.callee, '');
+        }
+        function checkAssignmentExpression(node) {
+            // Similar to checkLogicalExpressionForUnnecessaryConditionals, since
+            // a ||= b is equivalent to a || (a = b)
+            if (['||=', '&&='].includes(node.operator)) {
+                checkNode(node.left);
+            }
+            else if (node.operator === '??=') {
+                checkNodeForNullish(node.left);
+            }
+        }
+        return {
+            AssignmentExpression: checkAssignmentExpression,
+            BinaryExpression: checkIfBinaryExpressionIsNecessaryConditional,
+            CallExpression: checkCallExpression,
+            ConditionalExpression: (node) => checkNode(node.test),
+            DoWhileStatement: checkIfLoopIsNecessaryConditional,
+            ForStatement: checkIfLoopIsNecessaryConditional,
+            IfStatement: (node) => checkNode(node.test),
+            LogicalExpression: checkLogicalExpressionForUnnecessaryConditionals,
+            WhileStatement: checkIfLoopIsNecessaryConditional,
+            'MemberExpression[optional = true]': checkOptionalMemberExpression,
+            'CallExpression[optional = true]': checkOptionalCallExpression,
+        };
+    },
+});
+//# sourceMappingURL=no-unnecessary-condition.js.map

package/backend/node_modules/@typescript-eslint/eslint-plugin/dist/rules/no-unnecessary-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unnecessary-condition.js","sourceRoot":"","sources":["../../src/rules/no-unnecessary-condition.ts"],"names":[],"mappings":"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"}