@dereekb/util 13.12.0 → 13.12.2

package/eslint/index.cjs.js

@@ -909,7 +909,7 @@ function _non_iterable_rest$8() {
 function _sliced_to_array$8(arr, i) {
     return _array_with_holes$8(arr) || _iterable_to_array_limit$8(arr, i) || _unsupported_iterable_to_array$a(arr, i) || _non_iterable_rest$8();
 }
-function _type_of(obj) {
+function _type_of$1(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
@@ -1026,7 +1026,7 @@ function walkChildren(node, out) {
  * @param node - The AST node to traverse.
  * @param out - The accumulator array that receives counted `ReturnStatement` nodes.
  */ function collectCountedReturns(node, out) {
-    if (node === null || (typeof node === "undefined" ? "undefined" : _type_of(node)) !== 'object') return;
+    if (node === null || (typeof node === "undefined" ? "undefined" : _type_of$1(node)) !== 'object') return;
     if (Array.isArray(node)) {
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
@@ -1877,6 +1877,10 @@ function _non_iterable_spread$2() {
 function _to_consumable_array$2(arr) {
     return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$8(arr) || _non_iterable_spread$2();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array$8(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array$8(o, minLen);
@@ -2076,26 +2080,513 @@ function _unsupported_iterable_to_array$8(o, minLen) {
     return sourceCode.text.slice(range[0], range[1]);
 }
 /**
- * Returns true when every deprecated statement in `deprecated` appears AFTER every non-deprecated
- * analyzable statement in `analyzable` (i.e., the deprecated section is already at the bottom of
- * the file). This is the condition under which the autofix can simply insert the marker without
+ * Unwraps an `export` statement to the underlying declaration. Returns the node itself when it is
+ * not an export wrapper.
+ *
+ * @param statement - The top-level statement node.
+ * @returns The inner declaration for export wrappers, otherwise the statement itself.
+ */ function unwrapDeclaration(statement) {
+    var declaration = statement;
+    if ((statement.type === 'ExportNamedDeclaration' || statement.type === 'ExportDefaultDeclaration') && statement.declaration != null) {
+        declaration = statement.declaration;
+    }
+    return declaration;
+}
+/**
+ * Recursively collects the binding names introduced by a binding pattern (`Identifier`,
+ * `ObjectPattern`, `ArrayPattern`, including defaults and rest elements).
+ *
+ * @param node - A binding pattern to walk; missing array-pattern holes contribute no names.
+ * @returns The flat list of bound identifier names.
+ */ function collectPatternNames(node) {
+    var names = [];
+    if (node != null) {
+        if (node.type === 'Identifier') {
+            names.push(node.name);
+        } else if (node.type === 'ObjectPattern') {
+            var _node_properties;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = ((_node_properties = node.properties) !== null && _node_properties !== void 0 ? _node_properties : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var property = _step.value;
+                    var _names;
+                    (_names = names).push.apply(_names, _to_consumable_array$2(collectPatternNames(property.type === 'RestElement' ? property.argument : property.value)));
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        } else if (node.type === 'ArrayPattern') {
+            var _node_elements;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = ((_node_elements = node.elements) !== null && _node_elements !== void 0 ? _node_elements : [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var element = _step1.value;
+                    var _names1;
+                    (_names1 = names).push.apply(_names1, _to_consumable_array$2(collectPatternNames((element === null || element === void 0 ? void 0 : element.type) === 'RestElement' ? element.argument : element)));
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        } else if (node.type === 'AssignmentPattern') {
+            var _names2;
+            (_names2 = names).push.apply(_names2, _to_consumable_array$2(collectPatternNames(node.left)));
+        } else if (node.type === 'RestElement') {
+            var _names3;
+            (_names3 = names).push.apply(_names3, _to_consumable_array$2(collectPatternNames(node.argument)));
+        }
+    }
+    return names;
+}
+/**
+ * Returns the binding names a top-level statement introduces: variable declarator ids, an
+ * import's local specifier names, or a function/class/interface/type/enum declaration id.
+ *
+ * @param statement - The top-level statement node.
+ * @returns The names bound by the statement.
+ */ function getDeclaredBindingNames(statement) {
+    var _declaration_id;
+    var names = [];
+    var declaration = unwrapDeclaration(statement);
+    if (declaration.type === 'VariableDeclaration') {
+        var _declaration_declarations;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = ((_declaration_declarations = declaration.declarations) !== null && _declaration_declarations !== void 0 ? _declaration_declarations : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var declarator = _step.value;
+                var _names;
+                (_names = names).push.apply(_names, _to_consumable_array$2(collectPatternNames(declarator.id)));
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    } else if (declaration.type === 'ImportDeclaration') {
+        var _declaration_specifiers;
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = ((_declaration_specifiers = declaration.specifiers) !== null && _declaration_specifiers !== void 0 ? _declaration_specifiers : [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var specifier = _step1.value;
+                var _specifier_local;
+                if (typeof ((_specifier_local = specifier.local) === null || _specifier_local === void 0 ? void 0 : _specifier_local.name) === 'string') {
+                    names.push(specifier.local.name);
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+    } else if (((_declaration_id = declaration.id) === null || _declaration_id === void 0 ? void 0 : _declaration_id.type) === 'Identifier') {
+        names.push(declaration.id.name);
+    }
+    return names;
+}
+/**
+ * Returns true for AST-walk keys that must not be descended into: the `parent` back-reference
+ * (which would escape the subtree) and the `loc`/`range` position metadata.
+ *
+ * @param key - The property key being considered for traversal.
+ * @returns True when the key should be skipped.
+ */ function isIdentifierWalkSkipKey(key) {
+    return key === 'parent' || key === 'loc' || key === 'range';
+}
+/**
+ * Collects every `Identifier` name reachable from an AST record (a node with a string `type`),
+ * recursing into its child nodes while skipping the keys flagged by {@link isIdentifierWalkSkipKey}.
+ *
+ * @param record - An AST node, keyed by its properties.
+ * @returns The set of identifier names found within the node.
+ */ function collectIdentifierNamesFromRecord(record) {
+    var names = new Set();
+    if (record.type === 'Identifier' && typeof record.name === 'string') {
+        names.add(record.name);
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.keys(record)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            if (!isIdentifierWalkSkipKey(key)) {
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = collectIdentifierNames(record[key])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var name = _step1.value;
+                        names.add(name);
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Recursively collects every `Identifier` name reachable from a value, staying within the subtree.
+ *
+ * Used both for the value-alias check (over a declarator `init`) and the reverse-reference safety
+ * net (over a whole statement). Over-collection is acceptable for both callers: it only makes the
+ * safety net more conservative and the alias check more permissive toward genuine aliases.
+ *
+ * @param node - The subtree root to scan (an AST node, an array of nodes, or a leaf value).
+ * @returns The set of identifier names found in the subtree.
+ */ function collectIdentifierNames(node) {
+    var names = new Set();
+    if (Array.isArray(node)) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = node[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var item = _step.value;
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = collectIdentifierNames(item)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var name = _step1.value;
+                        names.add(name);
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    } else if (node != null && (typeof node === "undefined" ? "undefined" : _type_of(node)) === 'object' && typeof node.type === 'string') {
+        names = collectIdentifierNamesFromRecord(node);
+    }
+    return names;
+}
+/**
+ * Builds a map of every top-level binding name in the file to whether its declaration carries an
+ * `@deprecated` tag. A name declared more than once is considered non-deprecated when any of its
+ * declarations is non-deprecated.
+ *
+ * @param sourceCode - The ESLint `SourceCode` instance.
+ * @param body - All top-level program-body statements.
+ * @returns Whether each top-level binding name is declared as `@deprecated`, keyed by that name.
+ */ function buildBindingDeprecationMap(sourceCode, body) {
+    var bindingDeprecation = new Map();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var statement = _step.value;
+            var deprecated = statementIsDeprecated(sourceCode, statement);
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = getDeclaredBindingNames(statement)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var name = _step1.value;
+                    var existing = bindingDeprecation.get(name);
+                    bindingDeprecation.set(name, existing === undefined ? deprecated : existing && deprecated);
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return bindingDeprecation;
+}
+/**
+ * Returns true when a `@deprecated` statement is a runtime *value alias* — a `VariableDeclaration`
+ * whose initializer references a non-deprecated binding declared elsewhere in the file (or an
+ * imported name). Literal-only initializers (`= 'SPED'`, `= 5`, object/array literals with no
+ * variable references) are primary definitions, not aliases, and return false.
+ *
+ * @param sourceCode - The ESLint `SourceCode` instance.
+ * @param statement - The top-level statement node.
+ * @param bindingDeprecation - Map of top-level binding name to deprecation flag.
+ * @returns True when the statement is a deprecated value alias.
+ */ function statementIsValueAlias(sourceCode, statement, bindingDeprecation) {
+    var isAlias = false;
+    var declaration = unwrapDeclaration(statement);
+    if (statementIsDeprecated(sourceCode, statement) && declaration.type === 'VariableDeclaration') {
+        var _declaration_declarations;
+        var ownNames = new Set(getDeclaredBindingNames(statement));
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = ((_declaration_declarations = declaration.declarations) !== null && _declaration_declarations !== void 0 ? _declaration_declarations : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var declarator = _step.value;
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = collectIdentifierNames(declarator.init)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var name = _step1.value;
+                        if (!ownNames.has(name) && bindingDeprecation.get(name) === false) {
+                            isAlias = true;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return isAlias;
+}
+/**
+ * Safety net for runtime value aliases: returns true when any name bound by `statement` is
+ * referenced by some *other* top-level statement in the file. Relocating such a value below those
+ * references would introduce a use-before-declaration / temporal-dead-zone error, so a referenced
+ * alias must stay in place.
+ *
+ * @param names - The names bound by the candidate statement.
+ * @param statement - The candidate statement (excluded from the scan).
+ * @param body - All top-level program-body statements.
+ * @returns True when another statement references one of `names`.
+ */ function isReferencedByOtherStatements(names, statement, body) {
+    var referenced = false;
+    if (names.length !== 0) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var other = _step.value;
+                if (other !== statement) {
+                    var otherNames = collectIdentifierNames(other);
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = names[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var name = _step1.value;
+                            if (otherNames.has(name)) {
+                                referenced = true;
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return referenced;
+}
+/**
+ * Collects the analyzable statements the rule may relocate to the `// COMPAT: Deprecated aliases`
+ * section.
+ *
+ * A `@deprecated` statement is movable when it is a type-only declaration (`TSTypeAliasDeclaration`
+ * or `TSInterfaceDeclaration`), which is erased at runtime and can never cause a
+ * use-before-declaration error, or a runtime value alias (see {@link statementIsValueAlias}) that
+ * is not referenced by any other statement in the file (see {@link isReferencedByOtherStatements}).
+ *
+ * Primary runtime definitions — literal-valued consts, functions, classes, enums — are never
+ * movable; they stay exactly where they are so the autofix cannot reorder a value below its uses.
+ *
+ * @param sourceCode - The ESLint `SourceCode` instance.
+ * @param body - All top-level program-body statements.
+ * @param analyzable - The analyzable subset of `body` in source order.
+ * @returns The movable statements in source order.
+ */ function computeMovableStatements(sourceCode, body, analyzable) {
+    var bindingDeprecation = buildBindingDeprecationMap(sourceCode, body);
+    var movable = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = analyzable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var statement = _step.value;
+            if (statementIsDeprecated(sourceCode, statement)) {
+                var declaration = unwrapDeclaration(statement);
+                var isMovable = false;
+                if (declaration.type === 'TSTypeAliasDeclaration' || declaration.type === 'TSInterfaceDeclaration') {
+                    isMovable = true;
+                } else if (statementIsValueAlias(sourceCode, statement, bindingDeprecation)) {
+                    isMovable = !isReferencedByOtherStatements(getDeclaredBindingNames(statement), statement, body);
+                }
+                if (isMovable) {
+                    movable.push(statement);
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return movable;
+}
+/**
+ * Returns true when every movable statement in `movable` appears AFTER every non-movable analyzable
+ * statement in `analyzable` (i.e., the deprecated-alias section is already at the bottom of the
+ * file). This is the condition under which the autofix can simply insert the marker without
  * reordering statements.
  *
  * @param analyzable - All analyzable top-level statements in source order.
- * @param deprecated - The subset that carry `@deprecated`.
- * @returns True when no non-deprecated statement appears after the first deprecated one.
- */ function allDeprecatedAtBottom(analyzable, deprecated) {
+ * @param movable - The movable subset (relocatable deprecated aliases).
+ * @returns True when no non-movable statement appears after the first movable one.
+ */ function allMovableStatementsAtBottom(analyzable, movable) {
     var atBottom = true;
-    if (deprecated.length !== 0) {
-        var firstDeprecatedStart = deprecated[0].range[0];
+    if (movable.length !== 0) {
+        var firstMovableStart = movable[0].range[0];
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
             for(var _iterator = analyzable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                 var stmt = _step.value;
-                if (stmt.range[0] > firstDeprecatedStart) {
-                    // Statement appears after the first deprecated one. It must itself be deprecated.
-                    var isDeprecated = deprecated.includes(stmt);
-                    if (!isDeprecated) {
+                if (stmt.range[0] > firstMovableStart) {
+                    // Statement appears after the first movable one. It must itself be movable.
+                    var isMovable = movable.includes(stmt);
+                    if (!isMovable) {
                         atBottom = false;
                     }
                 }
@@ -2135,18 +2626,18 @@ function _unsupported_iterable_to_array$8(o, minLen) {
     };
 }
 /**
- * Builds the fix for the interleaved case: cut every deprecated block out of the file and re-emit
+ * Builds the fix for the interleaved case: cut every movable block out of the file and re-emit
  * them in source order at EOF, preceded by the marker.
  *
  * @param sourceCode - The ESLint `SourceCode` instance.
- * @param deprecatedStatements - Deprecated statements in source order.
- * @returns A fix function that removes and re-appends each deprecated block.
- */ function buildInterleavedFix(sourceCode, deprecatedStatements) {
+ * @param movableStatements - Movable deprecated-alias statements in source order.
+ * @returns A fix function that removes and re-appends each movable block.
+ */ function buildInterleavedFix(sourceCode, movableStatements) {
     var blockRanges = [];
     var blockTexts = [];
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator = deprecatedStatements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+        for(var _iterator = movableStatements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var stmt = _step.value;
             var range = getStatementBlockRange(sourceCode, stmt);
             blockRanges.push(range);
@@ -2189,19 +2680,19 @@ function _unsupported_iterable_to_array$8(o, minLen) {
 }
 /**
  * Reports the `missingCompatMarker` violation, choosing between the marker-only and interleaved
- * fix strategies based on whether the deprecated tail is already at the bottom of the file.
+ * fix strategies based on whether the movable tail is already at the bottom of the file.
  *
  * @param args - Inputs grouped as a single config object.
  * @param args.context - The ESLint rule context.
  * @param args.sourceCode - The ESLint `SourceCode` instance.
  * @param args.analyzable - All analyzable top-level statements in source order.
- * @param args.deprecatedStatements - The subset that carry `@deprecated`.
+ * @param args.movableStatements - The movable (relocatable deprecated-alias) subset.
  */ function reportMissingMarker(args) {
-    var context = args.context, sourceCode = args.sourceCode, analyzable = args.analyzable, deprecatedStatements = args.deprecatedStatements;
-    var firstDeprecated = deprecatedStatements[0];
-    var fixFn = allDeprecatedAtBottom(analyzable, deprecatedStatements) ? buildMarkerOnlyFix(sourceCode, firstDeprecated) : buildInterleavedFix(sourceCode, deprecatedStatements);
+    var context = args.context, sourceCode = args.sourceCode, analyzable = args.analyzable, movableStatements = args.movableStatements;
+    var firstMovable = movableStatements[0];
+    var fixFn = allMovableStatementsAtBottom(analyzable, movableStatements) ? buildMarkerOnlyFix(sourceCode, firstMovable) : buildInterleavedFix(sourceCode, movableStatements);
     context.report({
-        node: firstDeprecated,
+        node: firstMovable,
         messageId: 'missingCompatMarker',
         fix: fixFn
     });
@@ -2255,17 +2746,23 @@ function _unsupported_iterable_to_array$8(o, minLen) {
     };
 }
 /**
- * Reports the first misplaced deprecated block (above the marker) and the first misplaced
+ * Reports the first misplaced movable alias (above the marker) and the first misplaced
  * non-deprecated block (below the marker). At most one of each is reported per pass; ESLint's
  * autofix loop converges across multiple violations.
  *
+ * Only movable statements are pulled down below the marker; only statements that are not
+ * `@deprecated` at all are pushed up above it. A deprecated-but-not-movable statement (a primary
+ * definition such as a literal-valued const) sitting below an existing marker is left in place, so
+ * files that already carry a marker are not re-churned.
+ *
  * @param args - Inputs grouped as a single config object.
  * @param args.context - The ESLint rule context.
  * @param args.sourceCode - The ESLint `SourceCode` instance.
  * @param args.analyzable - All analyzable top-level statements in source order.
  * @param args.markerOffset - The marker comment's start offset.
+ * @param args.movableSet - The set of movable (relocatable deprecated-alias) statements.
  */ function reportMisplacedStatements(args) {
-    var context = args.context, sourceCode = args.sourceCode, analyzable = args.analyzable, markerOffset = args.markerOffset;
+    var context = args.context, sourceCode = args.sourceCode, analyzable = args.analyzable, markerOffset = args.markerOffset, movableSet = args.movableSet;
     var marker = {
         comment: findCompatMarkerComment(sourceCode),
         offset: markerOffset
@@ -2277,8 +2774,9 @@ function _unsupported_iterable_to_array$8(o, minLen) {
         for(var _iterator = analyzable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var stmt = _step.value;
             var isAfterMarker = stmt.range[0] > markerOffset;
+            var isMovable = movableSet.has(stmt);
             var isDeprecated = statementIsDeprecated(sourceCode, stmt);
-            if (isDeprecated && !isAfterMarker && !reportedAliasAboveMarker) {
+            if (isMovable && !isAfterMarker && !reportedAliasAboveMarker) {
                 context.report({
                     node: stmt,
                     messageId: 'deprecatedAliasNotAtBottom',
@@ -2310,56 +2808,29 @@ function _unsupported_iterable_to_array$8(o, minLen) {
     }
 }
 /**
- * Collects all analyzable top-level statements that carry an `@deprecated` JSDoc tag, preserving
- * source order.
+ * ESLint rule requiring that `@deprecated` *aliases* live at the bottom of the file under a
+ * `// COMPAT: Deprecated aliases` line comment, and that no non-deprecated exports follow the
+ * marker. The rule mirrors the workspace's "Deprecated Alias Placement" convention so that
+ * deprecated aliases stay segregated from current code and are easy to spot for removal.
  *
- * @param sourceCode - The ESLint `SourceCode` instance.
- * @param analyzable - All analyzable top-level statements in source order.
- * @returns The deprecated subset of `analyzable`.
- */ function collectDeprecatedStatements(sourceCode, analyzable) {
-    var deprecatedStatements = [];
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = analyzable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var stmt = _step.value;
-            if (statementIsDeprecated(sourceCode, stmt)) {
-                deprecatedStatements.push(stmt);
-            }
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    return deprecatedStatements;
-}
-/**
- * ESLint rule requiring that exports carrying a `@deprecated` JSDoc tag live at the bottom of the
- * file under a `// COMPAT: Deprecated aliases` line comment, and that no non-deprecated exports
- * follow the marker. The rule mirrors the workspace's "Deprecated Alias Placement" convention so
- * that deprecated aliases stay segregated from current code and are easy to spot for removal.
+ * Only *relocatable* deprecated statements participate (see {@link computeMovableStatements}):
+ * type-only declarations (always runtime-safe to move) and runtime value aliases — a
+ * `VariableDeclaration` whose initializer references a non-deprecated binding — that are not
+ * referenced elsewhere in the file. Primary runtime definitions (literal-valued consts, functions,
+ * classes, enums) and any value still referenced by other code are left exactly where they are, so
+ * the autofix can never reorder a value below its uses (a use-before-declaration error).
  *
  * The rule reports at most one violation per concern (missing marker, alias above marker,
  * non-deprecated below marker) to keep editor noise manageable; once the first violation in a
  * category is fixed, re-linting will surface the next one.
  *
  * Autofix coverage:
- *   - `missingCompatMarker` — inserts `// COMPAT: Deprecated aliases` and consolidates all
- *     deprecated blocks at the bottom of the file. When the deprecated tail is already at the
- *     bottom of the file, only the marker line is inserted (no statements are moved). When
- *     deprecated exports are interleaved with non-deprecated ones, the autofix removes each
- *     deprecated block from its current location and re-emits them in source order at the bottom
- *     of the file under the marker.
- *   - `deprecatedAliasNotAtBottom` — moves the misplaced deprecated block from above the marker to
+ *   - `missingCompatMarker` — inserts `// COMPAT: Deprecated aliases` and consolidates all movable
+ *     blocks at the bottom of the file. When the movable tail is already at the bottom of the file,
+ *     only the marker line is inserted (no statements are moved). When movable aliases are
+ *     interleaved with other statements, the autofix removes each movable block from its current
+ *     location and re-emits them in source order at the bottom of the file under the marker.
+ *   - `deprecatedAliasNotAtBottom` — moves the misplaced movable block from above the marker to
  *     just after the marker. One block per pass; ESLint's autofix loop converges across multiple
  *     violations.
  *   - `nonDeprecatedAfterMarker` — moves the misplaced non-deprecated block from below the marker
@@ -2371,12 +2842,12 @@ function _unsupported_iterable_to_array$8(o, minLen) {
         type: 'suggestion',
         fixable: 'code',
         docs: {
-            description: 'Require @deprecated exports to live at the bottom of the file under a // COMPAT: Deprecated aliases marker.',
+            description: 'Require @deprecated aliases to live at the bottom of the file under a // COMPAT: Deprecated aliases marker.',
             recommended: true
         },
         messages: {
-            missingCompatMarker: "File contains @deprecated exports but is missing the '// COMPAT: Deprecated aliases' marker line comment. Add the marker and move all @deprecated exports below it.",
-            deprecatedAliasNotAtBottom: "This @deprecated export should live below the '// COMPAT: Deprecated aliases' marker at the bottom of the file.",
+            missingCompatMarker: "File contains @deprecated aliases but is missing the '// COMPAT: Deprecated aliases' marker line comment. Add the marker and move the @deprecated aliases below it.",
+            deprecatedAliasNotAtBottom: "This @deprecated alias should live below the '// COMPAT: Deprecated aliases' marker at the bottom of the file.",
             nonDeprecatedAfterMarker: "This export is not @deprecated but appears after the '// COMPAT: Deprecated aliases' marker. Move it above the marker."
         },
         schema: []
@@ -2387,8 +2858,8 @@ function _unsupported_iterable_to_array$8(o, minLen) {
             var _programNode_body;
             var body = (_programNode_body = programNode.body) !== null && _programNode_body !== void 0 ? _programNode_body : [];
             var analyzable = body.filter(isAnalyzableExportLike);
-            var deprecatedStatements = collectDeprecatedStatements(sourceCode, analyzable);
-            if (deprecatedStatements.length === 0) {
+            var movableStatements = computeMovableStatements(sourceCode, body, analyzable);
+            if (movableStatements.length === 0) {
                 return;
             }
             var markerOffset = findCompatMarkerOffset(sourceCode);
@@ -2397,7 +2868,7 @@ function _unsupported_iterable_to_array$8(o, minLen) {
                     context: context,
                     sourceCode: sourceCode,
                     analyzable: analyzable,
-                    deprecatedStatements: deprecatedStatements
+                    movableStatements: movableStatements
                 });
                 return;
             }
@@ -2405,7 +2876,8 @@ function _unsupported_iterable_to_array$8(o, minLen) {
                 context: context,
                 sourceCode: sourceCode,
                 analyzable: analyzable,
-                markerOffset: markerOffset
+                markerOffset: markerOffset,
+                movableSet: new Set(movableStatements)
             });
         }
         return {
@@ -2514,19 +2986,28 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
     });
 }
 /**
- * Returns the index of the first line that begins with a JSDoc `@tag`, or `-1` when none exists.
+ * Computes, per line, whether it sits inside a fenced code block (a ```` ``` ```` block, typically
+ * an `@example` body) and therefore must not be treated as a tag boundary. Fence delimiter lines
+ * themselves are flagged too. Without this, `@`-prefixed lines inside a fence — decorators like
+ * `@Global()` / `@Module()`, or JSDoc snippets — would be mis-parsed as standalone JSDoc tags.
  *
  * @param lines - Parsed lines in source order.
- * @returns Zero-based line index of the first tag, or `-1` when no tag is present.
- */ function findFirstTagIndex(lines) {
-    var firstTagIndex = -1;
+ * @returns Boolean mask where `true` marks a line that must not start a tag.
+ */ function computeFenceMask(lines) {
+    var mask = lines.map(function() {
+        return false;
+    });
+    var fenceOpen = false;
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
         for(var _iterator = lines.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var _step_value = _sliced_to_array$7(_step.value, 2), i = _step_value[0], line = _step_value[1];
-            if (TAG_LINE_REGEX$1.test(line.text)) {
-                firstTagIndex = i;
-                break;
+            var isDelimiter = line.text.trimStart().startsWith('```');
+            if (isDelimiter) {
+                mask[i] = true;
+                fenceOpen = !fenceOpen;
+            } else {
+                mask[i] = fenceOpen;
             }
         }
     } catch (err) {
@@ -2543,6 +3024,32 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
             }
         }
     }
+    return mask;
+}
+/**
+ * Returns true when the line at `index` opens a JSDoc tag and is not masked out by a code fence.
+ *
+ * @param lines - Parsed lines in source order.
+ * @param fenceMask - Mask from {@link computeFenceMask} marking fenced lines.
+ * @param index - Line index to test.
+ * @returns True when the line begins a tag that should be treated as a tag boundary.
+ */ function isTagStart(lines, fenceMask, index) {
+    return !fenceMask[index] && TAG_LINE_REGEX$1.test(lines[index].text);
+}
+/**
+ * Returns the index of the first line that begins with a JSDoc `@tag`, or `-1` when none exists.
+ *
+ * @param lines - Parsed lines in source order.
+ * @param fenceMask - Mask from {@link computeFenceMask} marking fenced lines.
+ * @returns Zero-based line index of the first tag, or `-1` when no tag is present.
+ */ function findFirstTagIndex(lines, fenceMask) {
+    var firstTagIndex = -1;
+    for(var i = 0; i < lines.length; i += 1){
+        if (isTagStart(lines, fenceMask, i)) {
+            firstTagIndex = i;
+            break;
+        }
+    }
     return firstTagIndex;
 }
 /**
@@ -2640,15 +3147,16 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
  * Collects the tag line at `startIndex` plus every following non-tag continuation line.
  *
  * @param lines - All parsed lines in the comment.
+ * @param fenceMask - Mask from {@link computeFenceMask} marking fenced lines.
  * @param startIndex - Index of the `@tag` opening line.
  * @returns The collected tag lines and the index of the next unconsumed line.
- */ function collectTagLines(lines, startIndex) {
+ */ function collectTagLines(lines, fenceMask, startIndex) {
     var tagLines = [
         lines[startIndex]
     ];
     var j = startIndex + 1;
     while(j < lines.length){
-        if (TAG_LINE_REGEX$1.test(lines[j].text)) break;
+        if (isTagStart(lines, fenceMask, j)) break;
         tagLines.push(lines[j]);
         j += 1;
     }
@@ -2679,15 +3187,16 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
  * Builds a single parsed-tag record starting at `startIndex` in the line array.
  *
  * @param lines - All parsed lines in the comment.
+ * @param fenceMask - Mask from {@link computeFenceMask} marking fenced lines.
  * @param startIndex - Index of the `@tag` opening line.
  * @returns The parsed tag and the next unconsumed line index.
- */ function parseTagAt(lines, startIndex) {
+ */ function parseTagAt(lines, fenceMask, startIndex) {
     var line = lines[startIndex];
     var match = TAG_LINE_REGEX$1.exec(line.text);
     var tagName = match[1];
     var _extractTypeAnnotation = extractTypeAnnotation(match[2]), type = _extractTypeAnnotation.type, afterType = _extractTypeAnnotation.rest;
     var _extractParamName = extractParamName$1(tagName, afterType), name = _extractParamName.name, afterName = _extractParamName.rest;
-    var _collectTagLines = collectTagLines(lines, startIndex), tagLines = _collectTagLines.tagLines, nextIndex = _collectTagLines.nextIndex;
+    var _collectTagLines = collectTagLines(lines, fenceMask, startIndex), tagLines = _collectTagLines.tagLines, nextIndex = _collectTagLines.nextIndex;
     var description = buildTagDescription(afterName, tagLines);
     return {
         tag: {
@@ -2706,18 +3215,19 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
  * Parses every `@tag` block starting from `firstTagIndex` to the end of the line array.
  *
  * @param lines - All parsed lines in the comment.
+ * @param fenceMask - Mask from {@link computeFenceMask} marking fenced lines.
  * @param firstTagIndex - Index where tag parsing should begin (`-1` skips entirely).
  * @returns All parsed tags in source order.
- */ function parseTags(lines, firstTagIndex) {
+ */ function parseTags(lines, fenceMask, firstTagIndex) {
     var tags = [];
     if (firstTagIndex !== -1) {
         var i = firstTagIndex;
         while(i < lines.length){
-            if (!TAG_LINE_REGEX$1.test(lines[i].text)) {
+            if (!isTagStart(lines, fenceMask, i)) {
                 i += 1;
                 continue;
             }
-            var _parseTagAt = parseTagAt(lines, i), tag = _parseTagAt.tag, nextIndex = _parseTagAt.nextIndex;
+            var _parseTagAt = parseTagAt(lines, fenceMask, i), tag = _parseTagAt.tag, nextIndex = _parseTagAt.nextIndex;
             tags.push(tag);
             i = nextIndex;
         }
@@ -2741,14 +3251,15 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
  */ function parseJsdocComment(commentValue) {
     var singleLine = !commentValue.includes('\n');
     var lines = buildParsedLines(commentValue);
-    var firstTagIndex = findFirstTagIndex(lines);
+    var fenceMask = computeFenceMask(lines);
+    var firstTagIndex = findFirstTagIndex(lines, fenceMask);
     var descriptionLines = firstTagIndex === -1 ? lines.slice() : lines.slice(0, firstTagIndex);
     var trimmedDescription = trimBlankBoundaries(descriptionLines);
     var description = trimmedDescription.map(function(l) {
         return l.text;
     }).join('\n');
     var descriptionParagraphs = buildDescriptionParagraphs(trimmedDescription);
-    var tags = parseTags(lines, firstTagIndex);
+    var tags = parseTags(lines, fenceMask, firstTagIndex);
     return {
         lines: lines,
         descriptionLines: descriptionLines,